magic-comments-loader 1.5.0 → 1.5.1

package/dist/cjs/webpackExports.cjs

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackExports = exports.schema = void 0;
+var _util = require("./util.cjs");
+const configSchema = {
+  type: 'object',
+  properties: {
+    active: {
+      oneOf: [{
+        type: 'boolean'
+      }, {
+        instanceof: 'Function'
+      }]
+    },
+    exports: {
+      instanceof: 'Function'
+    }
+  },
+  additionalProperties: false
+};
+const schema = {
+  oneOf: [{
+    instanceof: 'Function'
+  }, {
+    type: 'object',
+    properties: {
+      config: configSchema,
+      overrides: (0, _util.getOverrideSchema)(configSchema)
+    },
+    required: ['config'],
+    additionalProperties: false
+  }]
+};
+exports.schema = schema;
+const defaultConfig = {
+  active: true
+};
+const getConfig = (value, filepath) => {
+  if (typeof value === 'function') {
+    return {
+      ...defaultConfig,
+      exports: value
+    };
+  }
+  let config = {
+    ...defaultConfig,
+    ...value.config
+  };
+  if (Array.isArray(value.overrides)) {
+    config = (0, _util.getOverrideConfig)(value.overrides, filepath, config);
+  }
+  return config;
+};
+const webpackExports = (filepath, importPath, value) => {
+  let exports = '';
+  let configExports = [];
+  const config = getConfig(value, filepath);
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive || typeof config.exports !== 'function') {
+    return '';
+  }
+  configExports = config.exports(filepath, importPath);
+  if (!Array.isArray(configExports)) {
+    return '';
+  }
+  exports = `["${configExports.reduce((curr, next) => `${curr}", "${next}`)}"]`;
+  return `webpackExports: ${exports}`;
+};
+exports.webpackExports = webpackExports;

package/dist/cjs/webpackFetchPriority.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackFetchPriority = exports.schema = void 0;
+var _enumComment = require("./enumComment.cjs");
+const {
+  comment: webpackFetchPriority,
+  schema
+} = (0, _enumComment.getEnumComment)('fetchPriority', ['high', 'low', 'auto'], 'auto');
+exports.schema = schema;
+exports.webpackFetchPriority = webpackFetchPriority;

package/dist/cjs/webpackIgnore.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackIgnore = exports.schema = void 0;
+var _booleanComment = require("./booleanComment.cjs");
+const schema = (0, _booleanComment.getSchema)();
+exports.schema = schema;
+const webpackIgnore = (filepath, importPath, value, match) => {
+  const config = (0, _booleanComment.getConfig)(value, match, filepath, importPath);
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive) {
+    return '';
+  }
+  return 'webpackIgnore: true';
+};
+exports.webpackIgnore = webpackIgnore;

package/dist/cjs/webpackInclude.cjs

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

package/dist/cjs/webpackMode.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackMode = exports.schema = void 0;
+var _enumComment = require("./enumComment.cjs");
+const {
+  comment: webpackMode,
+  schema
+} = (0, _enumComment.getEnumComment)('mode', ['lazy', 'lazy-once', 'eager', 'weak'], 'lazy');
+exports.schema = schema;
+exports.webpackMode = webpackMode;

package/dist/cjs/webpackPrefetch.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackPrefetch = exports.schema = void 0;
+var _booleanComment = require("./booleanComment.cjs");
+const schema = (0, _booleanComment.getSchema)();
+exports.schema = schema;
+const webpackPrefetch = (filepath, importPath, value, match) => {
+  const config = (0, _booleanComment.getConfig)(value, match, filepath, importPath);
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive) {
+    return '';
+  }
+  return 'webpackPrefetch: true';
+};
+exports.webpackPrefetch = webpackPrefetch;

package/dist/cjs/webpackPreload.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackPreload = exports.schema = void 0;
+var _booleanComment = require("./booleanComment.cjs");
+const schema = (0, _booleanComment.getSchema)();
+exports.schema = schema;
+const webpackPreload = (filepath, importPath, value, match) => {
+  const config = (0, _booleanComment.getConfig)(value, match, filepath, importPath);
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive) {
+    return '';
+  }
+  return 'webpackPreload: true';
+};
+exports.webpackPreload = webpackPreload;

package/dist/comment.js

@@ -0,0 +1,17 @@
+import { commentFor } from './strategy.js';
+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 => 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;
+};
+export { getCommenter };

package/dist/enumComment.js

@@ -0,0 +1,93 @@
+import { getOverrideConfig, getOverrideSchema } from './util.js';
+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: 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 = 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
+  };
+};
+export { getEnumComment };

package/dist/index.js

@@ -0,0 +1 @@
+export { loader as default } from './loader.js';

package/dist/loader.js

@@ -0,0 +1,19 @@
+import { validate } from 'schema-utils';
+import { schema } from './schema.js';
+import { getCommenter } from './comment.js';
+import { dynamicImportsWithoutComments } from './util.js';
+const loader = function (source, map, meta) {
+  const options = this.getOptions();
+  const optionKeys = Object.keys(options);
+  const logger = this.getLogger('MCL');
+  validate(schema, options, {
+    name: 'magic-comments-loader'
+  });
+  const filepath = this.utils.contextify(this.rootContext, this.resourcePath);
+  const magicComments = getCommenter(filepath.replace(/^\.\/?/, ''), optionKeys.length > 0 ? options : {
+    match: 'module',
+    webpackChunkName: true
+  }, logger);
+  this.callback(null, source.replace(dynamicImportsWithoutComments, magicComments), map, meta);
+};
+export { loader };

package/dist/regexComment.js

@@ -0,0 +1,95 @@
+import { getOverrideConfig, getOverrideSchema } from './util.js';
+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: 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 = 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
+  };
+};
+export { getRegexComment };

package/dist/schema.js

@@ -0,0 +1,31 @@
+import { schema as webpackChunkNameSchema } from './webpackChunkName.js';
+import { schema as webpackFetchPrioritySchema } from './webpackFetchPriority.js';
+import { schema as webpackModeSchema } from './webpackMode.js';
+import { schema as webpackIgnoreSchema } from './webpackIgnore.js';
+import { schema as webpackPrefetchSchema } from './webpackPrefetch.js';
+import { schema as webpackPreloadSchema } from './webpackPreload.js';
+import { schema as webpackExportsSchema } from './webpackExports.js';
+import { schema as webpackIncludeSchema } from './webpackInclude.js';
+import { schema as webpackExcludeSchema } from './webpackExclude.js';
+const schema = {
+  type: 'object',
+  properties: {
+    verbose: {
+      type: 'boolean'
+    },
+    match: {
+      enum: ['module', 'import']
+    },
+    webpackChunkName: webpackChunkNameSchema,
+    webpackFetchPriority: webpackFetchPrioritySchema,
+    webpackMode: webpackModeSchema,
+    webpackIgnore: webpackIgnoreSchema,
+    webpackPrefetch: webpackPrefetchSchema,
+    webpackPreload: webpackPreloadSchema,
+    webpackExports: webpackExportsSchema,
+    webpackInclude: webpackIncludeSchema,
+    webpackExclude: webpackExcludeSchema
+  },
+  additionalProperties: false
+};
+export { schema };

package/dist/strategy.js

@@ -0,0 +1,21 @@
+import { webpackChunkName } from './webpackChunkName.js';
+import { webpackFetchPriority } from './webpackFetchPriority.js';
+import { webpackMode } from './webpackMode.js';
+import { webpackIgnore } from './webpackIgnore.js';
+import { webpackPreload } from './webpackPreload.js';
+import { webpackPrefetch } from './webpackPrefetch.js';
+import { webpackExports } from './webpackExports.js';
+import { webpackInclude } from './webpackInclude.js';
+import { webpackExclude } from './webpackExclude.js';
+const commentFor = {
+  webpackChunkName,
+  webpackFetchPriority,
+  webpackMode,
+  webpackIgnore,
+  webpackPreload,
+  webpackPrefetch,
+  webpackExports,
+  webpackInclude,
+  webpackExclude
+};
+export { commentFor };

package/dist/util.js

@@ -0,0 +1,51 @@
+import micromatch from 'micromatch';
+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.isMatch(path, glob))) && notglobs.every(notglob => micromatch.isMatch(path, notglob));
+};
+const getOverrideSchema = commentSchema => ({
+  type: 'array',
+  items: {
+    type: 'object',
+    properties: {
+      config: commentSchema,
+      files: {
+        oneOf: [{
+          type: 'string'
+        }, {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }]
+      }
+    },
+    additionalProperties: false
+  }
+});
+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;
+};
+const importPrefix = /^(?:(\.{1,2}\/)+)|^\/|^.+:\/\/\/?[.-\w]+\//;
+const dynamicImportsWithoutComments = /(?<![\w.]|#!|(?:\/{2}.+\n?)+|\/\*[\s\w]*?|\*.+?|['"`][^)$,\n]*)import\s*\((?!\s*\/\*)(?<path>\s*?['"`][^)]+['"`]\s*)\)(?!\s*?\*\/)/gm;
+export { getOverrideConfig, getOverrideSchema, pathIsMatch, importPrefix, dynamicImportsWithoutComments };

package/dist/webpackChunkName.js

@@ -0,0 +1,54 @@
+import { parse } from 'path';
+import { getSchema, getConfig } from './booleanComment.js';
+const schema = getSchema({
+  type: 'object',
+  properties: {
+    active: {
+      oneOf: [{
+        type: 'boolean'
+      }, {
+        instanceof: 'Function'
+      }]
+    },
+    basename: {
+      type: 'boolean'
+    }
+  },
+  additionalProperties: false
+});
+const webpackChunkName = (filepath, importPath, value, match) => {
+  const config = 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
+  } = 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}"`;
+};
+export { webpackChunkName, schema };

package/dist/webpackExclude.js

@@ -0,0 +1,6 @@
+import { getRegexComment } from './regexComment.js';
+const {
+  comment: webpackExclude,
+  schema
+} = getRegexComment('exclude');
+export { webpackExclude, schema };

package/dist/webpackExports.js

@@ -0,0 +1,65 @@
+import { getOverrideConfig, getOverrideSchema } from './util.js';
+const configSchema = {
+  type: 'object',
+  properties: {
+    active: {
+      oneOf: [{
+        type: 'boolean'
+      }, {
+        instanceof: 'Function'
+      }]
+    },
+    exports: {
+      instanceof: 'Function'
+    }
+  },
+  additionalProperties: false
+};
+const schema = {
+  oneOf: [{
+    instanceof: 'Function'
+  }, {
+    type: 'object',
+    properties: {
+      config: configSchema,
+      overrides: getOverrideSchema(configSchema)
+    },
+    required: ['config'],
+    additionalProperties: false
+  }]
+};
+const defaultConfig = {
+  active: true
+};
+const getConfig = (value, filepath) => {
+  if (typeof value === 'function') {
+    return {
+      ...defaultConfig,
+      exports: value
+    };
+  }
+  let config = {
+    ...defaultConfig,
+    ...value.config
+  };
+  if (Array.isArray(value.overrides)) {
+    config = getOverrideConfig(value.overrides, filepath, config);
+  }
+  return config;
+};
+const webpackExports = (filepath, importPath, value) => {
+  let exports = '';
+  let configExports = [];
+  const config = getConfig(value, filepath);
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive || typeof config.exports !== 'function') {
+    return '';
+  }
+  configExports = config.exports(filepath, importPath);
+  if (!Array.isArray(configExports)) {
+    return '';
+  }
+  exports = `["${configExports.reduce((curr, next) => `${curr}", "${next}`)}"]`;
+  return `webpackExports: ${exports}`;
+};
+export { webpackExports, schema };

package/dist/webpackFetchPriority.js

@@ -0,0 +1,6 @@
+import { getEnumComment } from './enumComment.js';
+const {
+  comment: webpackFetchPriority,
+  schema
+} = getEnumComment('fetchPriority', ['high', 'low', 'auto'], 'auto');
+export { webpackFetchPriority, schema };

package/dist/webpackIgnore.js

@@ -0,0 +1,11 @@
+import { getSchema, getConfig } from './booleanComment.js';
+const schema = getSchema();
+const webpackIgnore = (filepath, importPath, value, match) => {
+  const config = getConfig(value, match, filepath, importPath);
+  const isActive = typeof config.active === 'function' ? config.active(filepath, importPath) : config.active;
+  if (!isActive) {
+    return '';
+  }
+  return 'webpackIgnore: true';
+};
+export { webpackIgnore, schema };

package/dist/webpackInclude.js

@@ -0,0 +1,6 @@
+import { getRegexComment } from './regexComment.js';
+const {
+  comment: webpackInclude,
+  schema
+} = getRegexComment('include');
+export { webpackInclude, schema };

package/dist/webpackMode.js

@@ -0,0 +1,6 @@
+import { getEnumComment } from './enumComment.js';
+const {
+  comment: webpackMode,
+  schema
+} = getEnumComment('mode', ['lazy', 'lazy-once', 'eager', 'weak'], 'lazy');
+export { webpackMode, schema };