magic-comments-loader 1.5.0 → 1.5.1

package/dist/booleanComment.js

@@ -0,0 +1,90 @@
+import { getOverrideSchema, pathIsMatch, importPrefix } from './util.js';
+const defaultSchema = {
+  type: 'object',
+  properties: {
+    active: {
+      oneOf: [{
+        type: 'boolean'
+      }, {
+        instanceof: 'Function'
+      }]
+    }
+  },
+  additionalProperties: false
+};
+const getSchema = (commentSchema = defaultSchema) => ({
+  oneOf: [{
+    type: 'boolean'
+  }, {
+    type: 'string'
+  }, {
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }, {
+    instanceof: 'Function'
+  }, {
+    type: 'object',
+    properties: {
+      config: commentSchema,
+      overrides: getOverrideSchema(commentSchema)
+    },
+    required: ['config'],
+    additionalProperties: false
+  }]
+});
+const getConfig = (value, match, filepath, importPath, defaultConfig = {
+  active: true
+}) => {
+  const path = match === 'import' ? importPath.replace(importPrefix, '') : filepath;
+  if (value === true) {
+    return defaultConfig;
+  }
+  if (value === false) {
+    return {
+      ...defaultConfig,
+      active: false
+    };
+  }
+  if (Array.isArray(value) || typeof value === 'string') {
+    return {
+      ...defaultConfig,
+      active: pathIsMatch(path, value)
+    };
+  }
+  if (typeof value === 'function') {
+    const configValue = value(filepath, importPath);
+    if (configValue) {
+      return {
+        ...defaultConfig,
+        active: true,
+        dynamic: configValue
+      };
+    }
+    return {
+      ...defaultConfig,
+      active: false
+    };
+  }
+  let config = {
+    ...defaultConfig,
+    ...value.config
+  };
+  if (Array.isArray(value.overrides)) {
+    const {
+      overrides
+    } = value;
+    const length = overrides.length;
+    for (let i = 0; i < length; i++) {
+      if (pathIsMatch(path, overrides[i].files)) {
+        return {
+          ...config,
+          ...overrides[i].config
+        };
+      }
+    }
+  }
+  return config;
+};
+export { getSchema, getConfig };

package/dist/cjs/booleanComment.cjs

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSchema = exports.getConfig = void 0;
+var _util = require("./util.cjs");
+const defaultSchema = {
+  type: 'object',
+  properties: {
+    active: {
+      oneOf: [{
+        type: 'boolean'
+      }, {
+        instanceof: 'Function'
+      }]
+    }
+  },
+  additionalProperties: false
+};
+const getSchema = (commentSchema = defaultSchema) => ({
+  oneOf: [{
+    type: 'boolean'
+  }, {
+    type: 'string'
+  }, {
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }, {
+    instanceof: 'Function'
+  }, {
+    type: 'object',
+    properties: {
+      config: commentSchema,
+      overrides: (0, _util.getOverrideSchema)(commentSchema)
+    },
+    required: ['config'],
+    additionalProperties: false
+  }]
+});
+exports.getSchema = getSchema;
+const getConfig = (value, match, filepath, importPath, defaultConfig = {
+  active: true
+}) => {
+  const path = match === 'import' ? importPath.replace(_util.importPrefix, '') : filepath;
+  if (value === true) {
+    return defaultConfig;
+  }
+  if (value === false) {
+    return {
+      ...defaultConfig,
+      active: false
+    };
+  }
+  if (Array.isArray(value) || typeof value === 'string') {
+    return {
+      ...defaultConfig,
+      active: (0, _util.pathIsMatch)(path, value)
+    };
+  }
+  if (typeof value === 'function') {
+    const configValue = value(filepath, importPath);
+    if (configValue) {
+      return {
+        ...defaultConfig,
+        active: true,
+        dynamic: configValue
+      };
+    }
+    return {
+      ...defaultConfig,
+      active: false
+    };
+  }
+  let config = {
+    ...defaultConfig,
+    ...value.config
+  };
+  if (Array.isArray(value.overrides)) {
+    const {
+      overrides
+    } = value;
+    const length = overrides.length;
+    for (let i = 0; i < length; i++) {
+      if ((0, _util.pathIsMatch)(path, overrides[i].files)) {
+        return {
+          ...config,
+          ...overrides[i].config
+        };
+      }
+    }
+  }
+  return config;
+};
+exports.getConfig = getConfig;

package/dist/cjs/comment.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCommenter = void 0;
+var _strategy = require("./strategy.cjs");
+const getCommenter = (filepath, options, logger) => (rgxMatch, capturedImportPath) => {
+  const importPath = capturedImportPath.trim();
+  const bareImportPath = importPath.replace(/['"`]/g, '');
+  const {
+    verbose,
+    match,
+    ...magicCommentOptions
+  } = options;
+  const magicComment = Object.keys(magicCommentOptions).map(key => _strategy.commentFor[key](filepath, bareImportPath, magicCommentOptions[key], match)).filter(Boolean);
+  const magicImport = rgxMatch.replace(capturedImportPath, magicComment.length > 0 ? `/* ${magicComment.join(', ')} */ ${importPath}` : `${importPath}`);
+  if (verbose) {
+    logger.info(`${filepath} : ${magicImport}`);
+  }
+  return magicImport;
+};
+exports.getCommenter = getCommenter;

package/dist/cjs/enumComment.cjs

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnumComment = void 0;
+var _util = require("./util.cjs");
+const getEnumComment = (name, enums, defaultValue) => {
+  const configSchema = {
+    type: 'object',
+    properties: {
+      active: {
+        oneOf: [{
+          type: 'boolean'
+        }, {
+          instanceof: 'Function'
+        }]
+      },
+      [name]: {
+        oneOf: [{
+          enum: enums
+        }, {
+          instanceof: 'Function'
+        }]
+      }
+    },
+    additionalProperties: false
+  };
+  const schema = {
+    oneOf: [{
+      type: 'boolean'
+    }, {
+      type: 'string'
+    }, {
+      instanceof: 'Function'
+    }, {
+      type: 'object',
+      properties: {
+        config: configSchema,
+        overrides: (0, _util.getOverrideSchema)(configSchema)
+      },
+      required: ['config'],
+      additionalProperties: false
+    }]
+  };
+  const defaultConfig = {
+    active: true,
+    [name]: defaultValue
+  };
+  const getConfig = (value, filepath) => {
+    if (value === true) {
+      return defaultConfig;
+    }
+    if (value === false) {
+      return {
+        ...defaultConfig,
+        active: false
+      };
+    }
+    if (typeof value === 'string' || typeof value === 'function') {
+      return {
+        ...defaultConfig,
+        [name]: value
+      };
+    }
+    let config = {
+      ...defaultConfig,
+      ...value.config
+    };
+    if (Array.isArray(value.overrides)) {
+      config = (0, _util.getOverrideConfig)(value.overrides, filepath, config);
+    }
+    return config;
+  };
+  const comment = (filepath, importPath, value) => {
+    let enumValue = '';
+    const commentSuffix = `${name[0].toUpperCase()}${name.slice(1)}`;
+    const config = getConfig(value, filepath);
+    const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+    if (!isActive) {
+      return '';
+    }
+    if (typeof config[name] === 'function') {
+      enumValue = config[name](filepath, importPath);
+    }
+    if (typeof config[name] === 'string') {
+      enumValue = config[name];
+    }
+    if (!enums.includes(enumValue)) {
+      return '';
+    }
+    return `webpack${commentSuffix}: "${enumValue}"`;
+  };
+  return {
+    comment,
+    schema
+  };
+};
+exports.getEnumComment = getEnumComment;

package/dist/cjs/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _loader.loader;
+  }
+});
+var _loader = require("./loader.cjs");

package/dist/cjs/loader.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loader = void 0;
+var _schemaUtils = require("schema-utils");
+var _schema = require("./schema.cjs");
+var _comment = require("./comment.cjs");
+var _util = require("./util.cjs");
+const loader = function (source, map, meta) {
+  const options = this.getOptions();
+  const optionKeys = Object.keys(options);
+  const logger = this.getLogger('MCL');
+  (0, _schemaUtils.validate)(_schema.schema, options, {
+    name: 'magic-comments-loader'
+  });
+  const filepath = this.utils.contextify(this.rootContext, this.resourcePath);
+  const magicComments = (0, _comment.getCommenter)(filepath.replace(/^\.\/?/, ''), optionKeys.length > 0 ? options : {
+    match: 'module',
+    webpackChunkName: true
+  }, logger);
+  this.callback(null, source.replace(_util.dynamicImportsWithoutComments, magicComments), map, meta);
+};
+exports.loader = loader;

package/dist/cjs/regexComment.cjs

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRegexComment = void 0;
+var _util = require("./util.cjs");
+const getRegexComment = type => {
+  const configSchema = {
+    type: 'object',
+    properties: {
+      active: {
+        oneOf: [{
+          type: 'boolean'
+        }, {
+          instanceof: 'Function'
+        }]
+      },
+      include: {
+        oneOf: [{
+          instanceof: 'Function'
+        }, {
+          instanceof: 'RegExp'
+        }]
+      },
+      exclude: {
+        oneOf: [{
+          instanceof: 'Function'
+        }, {
+          instanceof: 'RegExp'
+        }]
+      }
+    },
+    additionalProperties: false
+  };
+  const schema = {
+    oneOf: [{
+      instanceof: 'Function'
+    }, {
+      instanceof: 'RegExp'
+    }, {
+      type: 'object',
+      properties: {
+        config: configSchema,
+        overrides: (0, _util.getOverrideSchema)(configSchema)
+      },
+      required: ['config'],
+      additionalProperties: false
+    }]
+  };
+  const getConfig = (value, filepath) => {
+    if (typeof value === 'function' || value instanceof RegExp) {
+      return {
+        active: true,
+        [type]: value
+      };
+    }
+    let config = {
+      active: true,
+      ...value.config
+    };
+    if (Array.isArray(value.overrides)) {
+      config = (0, _util.getOverrideConfig)(value.overrides, filepath, config);
+    }
+    return config;
+  };
+  const comment = (filepath, importPath, value) => {
+    const config = getConfig(value, filepath);
+    const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+    let regex = null;
+    if (!isActive) {
+      return '';
+    }
+    if (typeof config[type] === 'function') {
+      regex = config[type](filepath, importPath);
+    }
+    if (config[type] instanceof RegExp) {
+      regex = config[type];
+    }
+    if (!(regex instanceof RegExp)) {
+      return '';
+    }
+    const source = regex.source;
+    const typeName = `${type[0].toUpperCase()}${type.slice(1)}`;
+    /**
+     * Check if the provided RegExp ends in one or more '*'
+     * and if so be sure to escape the ending '/' in the
+     * comments regular expression so as not to break the
+     * comment and cause a SyntaxError.
+     */
+    if (/(\*+)$/.test(source)) {
+      return `webpack${typeName}: /${source}\\/${regex.flags}`;
+    }
+    return `webpack${typeName}: /${source}/${regex.flags}`;
+  };
+  return {
+    comment,
+    schema
+  };
+};
+exports.getRegexComment = getRegexComment;

package/dist/cjs/schema.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.schema = void 0;
+var _webpackChunkName = require("./webpackChunkName.cjs");
+var _webpackFetchPriority = require("./webpackFetchPriority.cjs");
+var _webpackMode = require("./webpackMode.cjs");
+var _webpackIgnore = require("./webpackIgnore.cjs");
+var _webpackPrefetch = require("./webpackPrefetch.cjs");
+var _webpackPreload = require("./webpackPreload.cjs");
+var _webpackExports = require("./webpackExports.cjs");
+var _webpackInclude = require("./webpackInclude.cjs");
+var _webpackExclude = require("./webpackExclude.cjs");
+const schema = {
+  type: 'object',
+  properties: {
+    verbose: {
+      type: 'boolean'
+    },
+    match: {
+      enum: ['module', 'import']
+    },
+    webpackChunkName: _webpackChunkName.schema,
+    webpackFetchPriority: _webpackFetchPriority.schema,
+    webpackMode: _webpackMode.schema,
+    webpackIgnore: _webpackIgnore.schema,
+    webpackPrefetch: _webpackPrefetch.schema,
+    webpackPreload: _webpackPreload.schema,
+    webpackExports: _webpackExports.schema,
+    webpackInclude: _webpackInclude.schema,
+    webpackExclude: _webpackExclude.schema
+  },
+  additionalProperties: false
+};
+exports.schema = schema;

package/dist/cjs/strategy.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commentFor = void 0;
+var _webpackChunkName = require("./webpackChunkName.cjs");
+var _webpackFetchPriority = require("./webpackFetchPriority.cjs");
+var _webpackMode = require("./webpackMode.cjs");
+var _webpackIgnore = require("./webpackIgnore.cjs");
+var _webpackPreload = require("./webpackPreload.cjs");
+var _webpackPrefetch = require("./webpackPrefetch.cjs");
+var _webpackExports = require("./webpackExports.cjs");
+var _webpackInclude = require("./webpackInclude.cjs");
+var _webpackExclude = require("./webpackExclude.cjs");
+const commentFor = {
+  webpackChunkName: _webpackChunkName.webpackChunkName,
+  webpackFetchPriority: _webpackFetchPriority.webpackFetchPriority,
+  webpackMode: _webpackMode.webpackMode,
+  webpackIgnore: _webpackIgnore.webpackIgnore,
+  webpackPreload: _webpackPreload.webpackPreload,
+  webpackPrefetch: _webpackPrefetch.webpackPrefetch,
+  webpackExports: _webpackExports.webpackExports,
+  webpackInclude: _webpackInclude.webpackInclude,
+  webpackExclude: _webpackExclude.webpackExclude
+};
+exports.commentFor = commentFor;

package/dist/cjs/util.cjs

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathIsMatch = exports.importPrefix = exports.getOverrideSchema = exports.getOverrideConfig = exports.dynamicImportsWithoutComments = void 0;
+var _micromatch = _interopRequireDefault(require("micromatch"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const pathIsMatch = (path, files) => {
+  const globs = [];
+  const notglobs = [];
+  if (!Array.isArray(files)) {
+    files = [files];
+  }
+  files.forEach(file => {
+    if (/^!/.test(file)) {
+      notglobs.push(file);
+    } else {
+      globs.push(file);
+    }
+  });
+  return (globs.length === 0 || globs.some(glob => _micromatch.default.isMatch(path, glob))) && notglobs.every(notglob => _micromatch.default.isMatch(path, notglob));
+};
+exports.pathIsMatch = pathIsMatch;
+const getOverrideSchema = commentSchema => ({
+  type: 'array',
+  items: {
+    type: 'object',
+    properties: {
+      config: commentSchema,
+      files: {
+        oneOf: [{
+          type: 'string'
+        }, {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }]
+      }
+    },
+    additionalProperties: false
+  }
+});
+exports.getOverrideSchema = getOverrideSchema;
+const getOverrideConfig = (overrides, filepath, config) => {
+  const length = overrides.length;
+  for (let i = 0; i < length; i++) {
+    if (pathIsMatch(filepath, overrides[i].files)) {
+      return {
+        ...config,
+        ...overrides[i].config
+      };
+    }
+  }
+  return config;
+};
+exports.getOverrideConfig = getOverrideConfig;
+const importPrefix = /^(?:(\.{1,2}\/)+)|^\/|^.+:\/\/\/?[.-\w]+\//;
+exports.importPrefix = importPrefix;
+const dynamicImportsWithoutComments = /(?<![\w.]|#!|(?:\/{2}.+\n?)+|\/\*[\s\w]*?|\*.+?|['"`][^)$,\n]*)import\s*\((?!\s*\/\*)(?<path>\s*?['"`][^)]+['"`]\s*)\)(?!\s*?\*\/)/gm;
+exports.dynamicImportsWithoutComments = dynamicImportsWithoutComments;

package/dist/cjs/webpackChunkName.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackChunkName = exports.schema = void 0;
+var _path = require("path");
+var _booleanComment = require("./booleanComment.cjs");
+const schema = (0, _booleanComment.getSchema)({
+  type: 'object',
+  properties: {
+    active: {
+      oneOf: [{
+        type: 'boolean'
+      }, {
+        instanceof: 'Function'
+      }]
+    },
+    basename: {
+      type: 'boolean'
+    }
+  },
+  additionalProperties: false
+});
+exports.schema = schema;
+const webpackChunkName = (filepath, importPath, value, match) => {
+  const config = (0, _booleanComment.getConfig)(value, match, filepath, importPath, {
+    active: true,
+    basename: false
+  });
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive) {
+    return '';
+  }
+  if (typeof config.dynamic === 'string') {
+    return `webpackChunkName: "${config.dynamic}"`;
+  }
+  const {
+    basename
+  } = config;
+  const {
+    dir,
+    name
+  } = (0, _path.parse)(importPath);
+  const segments = `${dir}/${name}`.split('/').filter(segment => /\w/.test(segment));
+  const chunkName = basename ? name : segments.reduce((prev, curr) => {
+    /**
+     * Check for dynamic expressions in imports.
+     * If it exists, it has to be at least the second path
+     * segment or greater, i.e. can not be the first.
+     *
+     * @see https://webpack.js.org/api/module-methods/#dynamic-expressions-in-import
+     */
+    if (/^\${/.test(curr)) {
+      return prev ? `${prev}-[request]` : '[request]';
+    }
+    return prev ? `${prev}-${curr}` : curr;
+  }, '');
+  return `webpackChunkName: "${chunkName}"`;
+};
+exports.webpackChunkName = webpackChunkName;

package/dist/cjs/webpackExclude.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackExclude = exports.schema = void 0;
+var _regexComment = require("./regexComment.cjs");
+const {
+  comment: webpackExclude,
+  schema
+} = (0, _regexComment.getRegexComment)('exclude');
+exports.schema = schema;
+exports.webpackExclude = webpackExclude;