@parcel/transformer-posthtml 2.0.0-nightly.92 → 2.0.0-nightly.926

package/lib/PostHTMLTransformer.js

@@ -5,42 +5,147 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _plugin = require("@parcel/plugin");
+function _plugin() {
+  const data = require("@parcel/plugin");
 
-var _posthtml = _interopRequireDefault(require("posthtml"));
+  _plugin = function () {
+    return data;
+  };
 
-var _posthtmlParser = _interopRequireDefault(require("posthtml-parser"));
+  return data;
+}
 
-var _posthtmlRender = _interopRequireDefault(require("posthtml-render"));
+function _path() {
+  const data = _interopRequireDefault(require("path"));
 
-var _nullthrows = _interopRequireDefault(require("nullthrows"));
+  _path = function () {
+    return data;
+  };
 
-var _semver = _interopRequireDefault(require("semver"));
+  return data;
+}
+
+function _posthtml() {
+  const data = _interopRequireDefault(require("posthtml"));
+
+  _posthtml = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _posthtmlParser() {
+  const data = require("posthtml-parser");
+
+  _posthtmlParser = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _posthtmlRender() {
+  const data = require("posthtml-render");
+
+  _posthtmlRender = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+
+  _nullthrows = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@parcel/utils");
+
+  _utils = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _loadPlugins = _interopRequireDefault(require("./loadPlugins"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _default = new _plugin.Transformer({
-  async getConfig({
-    asset,
-    options
+var _default = new (_plugin().Transformer)({
+  async loadConfig({
+    config,
+    options,
+    logger
   }) {
-    let config = await asset.getConfig(['.posthtmlrc', '.posthtmlrc.js', 'posthtml.config.js'], {
+    if (!config.isSource) {
+      return;
+    }
+
+    let configFile = await config.getConfig(['.posthtmlrc', '.posthtmlrc.js', 'posthtml.config.js'], {
       packageKey: 'posthtml'
     });
-    config = config || {}; // load plugins
 
-    config.plugins = await (0, _loadPlugins.default)(config.plugins, asset.filePath, options); // tells posthtml that we have already called parse
+    if (configFile) {
+      let isJavascript = _path().default.extname(configFile.filePath) === '.js';
+
+      if (isJavascript) {
+        // We have to invalidate on startup in case the config is non-deterministic,
+        // e.g. using unknown environment variables, reading from the filesystem, etc.
+        logger.warn({
+          message: 'WARNING: Using a JavaScript PostHTML config file means losing out on caching features of Parcel. Use a .posthtmlrc (JSON) file whenever possible.'
+        });
+        config.invalidateOnStartup(); // Also add the config as a dev dependency so we attempt to reload in watch mode.
+
+        config.addDevDependency({
+          specifier: (0, _utils().relativePath)(_path().default.dirname(config.searchPath), configFile.filePath),
+          resolveFrom: config.searchPath
+        });
+      } // Load plugins. This must be done before adding dev dependencies so we auto install.
+
+
+      let plugins = await (0, _loadPlugins.default)(configFile.contents.plugins, config.searchPath, options); // Now add dev dependencies so we invalidate when they change.
+
+      let pluginArray = Array.isArray(configFile.contents.plugins) ? configFile.contents.plugins : Object.keys(configFile.contents.plugins);
+
+      for (let p of pluginArray) {
+        if (typeof p === 'string') {
+          config.addDevDependency({
+            specifier: p,
+            resolveFrom: configFile.filePath
+          });
+        }
+      }
 
-    config.skipParse = true;
-    return config;
+      configFile.contents.plugins = plugins; // tells posthtml that we have already called parse
+
+      configFile.contents.skipParse = true;
+      delete configFile.contents.render;
+      return configFile.contents;
+    }
   },
 
   canReuseAST({
     ast
   }) {
-    return ast.type === 'posthtml' && _semver.default.satisfies(ast.version, '^0.4.0');
+    return ast.type === 'posthtml' && _semver().default.satisfies(ast.version, '^0.4.0');
   },
 
   async parse({
@@ -55,8 +160,10 @@ var _default = new _plugin.Transformer({
     return {
       type: 'posthtml',
       version: '0.4.1',
-      program: (0, _posthtmlParser.default)((await asset.getCode()), {
-        lowerCaseAttributeNames: true
+      program: (0, _posthtmlParser().parser)(await asset.getCode(), {
+        lowerCaseAttributeNames: true,
+        sourceLocations: true,
+        xmlMode: asset.type === 'xhtml'
       })
     };
   },
@@ -69,8 +176,10 @@ var _default = new _plugin.Transformer({
       return [asset];
     }
 
-    const ast = (0, _nullthrows.default)(asset.ast);
-    let res = await (0, _posthtml.default)(config.plugins).process(ast.program, config);
+    let ast = (0, _nullthrows().default)(await asset.getAST());
+    let res = await (0, _posthtml().default)(config.plugins).process(ast.program, { ...config,
+      plugins: config.plugins
+    });
 
     if (res.messages) {
       await Promise.all(res.messages.map(({
@@ -78,25 +187,30 @@ var _default = new _plugin.Transformer({
         file: filePath
       }) => {
         if (type === 'dependency') {
-          return asset.addIncludedFile({
-            filePath
-          });
+          return asset.invalidateOnFileChange(filePath);
         }
 
         return Promise.resolve();
       }));
     }
 
-    ast.program = res.tree;
-    asset.ast = ast;
+    asset.setAST({
+      type: 'posthtml',
+      version: '0.4.1',
+      program: JSON.parse(JSON.stringify(res.tree)) // posthtml adds functions to the AST that are not serializable
+
+    });
     return [asset];
   },
 
   generate({
+    ast,
     asset
   }) {
     return {
-      code: (0, _posthtmlRender.default)((0, _nullthrows.default)(asset.ast).program)
+      content: (0, _posthtmlRender().render)(ast.program, {
+        closingSingleTag: asset.type === 'xhtml' ? 'slash' : undefined
+      })
     };
   }
 

package/lib/loadPlugins.js

@@ -7,26 +7,23 @@ exports.default = loadExternalPlugins;
 
 async function loadExternalPlugins(plugins, relative, options) {
   if (Array.isArray(plugins)) {
-    return Promise.all(plugins.map(p => loadPlugin(p, relative, null, options.packageManager)).filter(Boolean));
+    return Promise.all(plugins.map(p => loadPlugin(p, relative, null, options.packageManager, options.shouldAutoInstall)).filter(Boolean));
   } else if (typeof plugins === 'object') {
-    let mapPlugins = await Promise.all(Object.keys(plugins).map(p => loadPlugin(p, relative, plugins[p], options.packageManager)));
+    let mapPlugins = await Promise.all(Object.keys(plugins).map(p => loadPlugin(p, relative, plugins[p], options.packageManager, options.shouldAutoInstall)));
     return mapPlugins.filter(Boolean);
   } else {
     return [];
   }
 }
 
-async function loadPlugin(pluginArg, relative, options = {}, packageManager) {
+async function loadPlugin(pluginArg, relative, options = {}, packageManager, shouldAutoInstall) {
   if (typeof pluginArg !== 'string') {
     return pluginArg;
   }
 
-  let plugin = await packageManager.require(pluginArg, relative);
+  let plugin = await packageManager.require(pluginArg, relative, {
+    shouldAutoInstall
+  });
   plugin = plugin.default || plugin;
-
-  if (options != null && typeof options === 'object' && Object.keys(options).length > 0) {
-    plugin = plugin(options);
-  }
-
-  return plugin.default || plugin;
+  return plugin(options);
 }

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@parcel/transformer-posthtml",
-  "version": "2.0.0-nightly.92+c0655c56",
+  "version": "2.0.0-nightly.926+8cabeae8",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
@@ -12,15 +16,17 @@
   "main": "lib/PostHTMLTransformer.js",
   "source": "src/PostHTMLTransformer.js",
   "engines": {
-    "parcel": "^2.0.0-alpha.1.1"
+    "node": ">= 12.0.0",
+    "parcel": "2.0.0-nightly.924+8cabeae8"
   },
   "dependencies": {
-    "@parcel/plugin": "2.0.0-nightly.92+c0655c56",
+    "@parcel/plugin": "2.0.0-nightly.926+8cabeae8",
+    "@parcel/utils": "2.0.0-nightly.926+8cabeae8",
     "nullthrows": "^1.1.1",
-    "posthtml": "^0.11.3",
-    "posthtml-parser": "^0.4.1",
-    "posthtml-render": "^1.1.5",
-    "semver": "^5.4.1"
+    "posthtml": "^0.16.5",
+    "posthtml-parser": "^0.10.1",
+    "posthtml-render": "^3.0.0",
+    "semver": "^5.7.1"
   },
-  "gitHead": "c0655c56f7973492fdb28671029ddd923f17a244"
+  "gitHead": "8cabeae83ca838134a003a52be468328e15d19ed"
 }

package/src/PostHTMLTransformer.js

@@ -2,30 +2,78 @@
 
 import {Transformer} from '@parcel/plugin';
 
+import path from 'path';
 import posthtml from 'posthtml';
-import parse from 'posthtml-parser';
-import render from 'posthtml-render';
+import {parser as parse} from 'posthtml-parser';
+import {render} from 'posthtml-render';
 import nullthrows from 'nullthrows';
 import semver from 'semver';
+import {relativePath} from '@parcel/utils';
 import loadPlugins from './loadPlugins';
 
-export default new Transformer({
-  async getConfig({asset, options}) {
-    let config = await asset.getConfig(
+export default (new Transformer({
+  async loadConfig({config, options, logger}) {
+    if (!config.isSource) {
+      return;
+    }
+
+    let configFile = await config.getConfig(
       ['.posthtmlrc', '.posthtmlrc.js', 'posthtml.config.js'],
       {
         packageKey: 'posthtml',
       },
     );
 
-    config = config || {};
-
-    // load plugins
-    config.plugins = await loadPlugins(config.plugins, asset.filePath, options);
+    if (configFile) {
+      let isJavascript = path.extname(configFile.filePath) === '.js';
+      if (isJavascript) {
+        // We have to invalidate on startup in case the config is non-deterministic,
+        // e.g. using unknown environment variables, reading from the filesystem, etc.
+        logger.warn({
+          message:
+            'WARNING: Using a JavaScript PostHTML config file means losing out on caching features of Parcel. Use a .posthtmlrc (JSON) file whenever possible.',
+        });
+
+        config.invalidateOnStartup();
+
+        // Also add the config as a dev dependency so we attempt to reload in watch mode.
+        config.addDevDependency({
+          specifier: relativePath(
+            path.dirname(config.searchPath),
+            configFile.filePath,
+          ),
+          resolveFrom: config.searchPath,
+        });
+      }
+
+      // Load plugins. This must be done before adding dev dependencies so we auto install.
+      let plugins = await loadPlugins(
+        configFile.contents.plugins,
+        config.searchPath,
+        options,
+      );
 
-    // tells posthtml that we have already called parse
-    config.skipParse = true;
-    return config;
+      // Now add dev dependencies so we invalidate when they change.
+      let pluginArray = Array.isArray(configFile.contents.plugins)
+        ? configFile.contents.plugins
+        : Object.keys(configFile.contents.plugins);
+      for (let p of pluginArray) {
+        if (typeof p === 'string') {
+          config.addDevDependency({
+            specifier: p,
+            resolveFrom: configFile.filePath,
+          });
+        }
+      }
+
+      configFile.contents.plugins = plugins;
+
+      // tells posthtml that we have already called parse
+      configFile.contents.skipParse = true;
+      delete configFile.contents.render;
+
+      return configFile.contents;
+    }
   },
 
   canReuseAST({ast}) {
@@ -43,6 +91,8 @@ export default new Transformer({
       version: '0.4.1',
       program: parse(await asset.getCode(), {
         lowerCaseAttributeNames: true,
+        sourceLocations: true,
+        xmlMode: asset.type === 'xhtml',
       }),
     };
   },
@@ -52,30 +102,37 @@ export default new Transformer({
       return [asset];
     }
 
-    const ast = nullthrows(asset.ast);
-
-    let res = await posthtml(config.plugins).process(ast.program, config);
+    let ast = nullthrows(await asset.getAST());
+    let res = await posthtml(config.plugins).process(ast.program, {
+      ...config,
+      plugins: config.plugins,
+    });
 
     if (res.messages) {
       await Promise.all(
         res.messages.map(({type, file: filePath}) => {
           if (type === 'dependency') {
-            return asset.addIncludedFile({filePath});
+            return asset.invalidateOnFileChange(filePath);
           }
           return Promise.resolve();
         }),
       );
     }
 
-    ast.program = res.tree;
-    asset.ast = ast;
+    asset.setAST({
+      type: 'posthtml',
+      version: '0.4.1',
+      program: JSON.parse(JSON.stringify(res.tree)), // posthtml adds functions to the AST that are not serializable
+    });
 
     return [asset];
   },
 
-  generate({asset}) {
+  generate({ast, asset}) {
     return {
-      code: render(nullthrows(asset.ast).program),
+      content: render(ast.program, {
+        closingSingleTag: asset.type === 'xhtml' ? 'slash' : undefined,
+      }),
     };
   },
-});
+}): Transformer);

package/src/loadPlugins.js

@@ -11,14 +11,28 @@ export default async function loadExternalPlugins(
   if (Array.isArray(plugins)) {
     return Promise.all(
       plugins
-        .map(p => loadPlugin(p, relative, null, options.packageManager))
+        .map(p =>
+          loadPlugin(
+            p,
+            relative,
+            null,
+            options.packageManager,
+            options.shouldAutoInstall,
+          ),
+        )
         .filter(Boolean),
     );
   } else if (typeof plugins === 'object') {
     let _plugins = plugins;
     let mapPlugins = await Promise.all(
       Object.keys(plugins).map(p =>
-        loadPlugin(p, relative, _plugins[p], options.packageManager),
+        loadPlugin(
+          p,
+          relative,
+          _plugins[p],
+          options.packageManager,
+          options.shouldAutoInstall,
+        ),
       ),
     );
     return mapPlugins.filter(Boolean);
@@ -32,21 +46,17 @@ async function loadPlugin(
   relative: FilePath,
   options: mixed = {},
   packageManager: PackageManager,
+  shouldAutoInstall: boolean,
 ): mixed {
   if (typeof pluginArg !== 'string') {
     return pluginArg;
   }
 
-  let plugin = await packageManager.require(pluginArg, relative);
-  plugin = plugin.default || plugin;
+  let plugin = await packageManager.require(pluginArg, relative, {
+    shouldAutoInstall,
+  });
 
-  if (
-    options != null &&
-    typeof options === 'object' &&
-    Object.keys(options).length > 0
-  ) {
-    plugin = plugin(options);
-  }
+  plugin = plugin.default || plugin;
 
-  return plugin.default || plugin;
+  return plugin(options);
 }