@corva/dc-platform-shared 0.0.0-2eb17ab → 0.0.0-2eb17ab-1

package/dist/node_modules/@corva/eslint-config-browser/node_modules/@babel/core/lib/config/partial.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadPrivatePartialConfig;
+exports.loadPartialConfig = void 0;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _plugin = _interopRequireDefault(require("./plugin"));
+
+var _util = require("./util");
+
+var _item = require("./item");
+
+var _configChain = require("./config-chain");
+
+var _environment = require("./helpers/environment");
+
+var _options = require("./validation/options");
+
+var _files = require("./files");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function* resolveRootMode(rootDir, rootMode) {
+  switch (rootMode) {
+    case "root":
+      return rootDir;
+
+    case "upward-optional":
+      {
+        const upwardRootDir = yield* (0, _files.findConfigUpwards)(rootDir);
+        return upwardRootDir === null ? rootDir : upwardRootDir;
+      }
+
+    case "upward":
+      {
+        const upwardRootDir = yield* (0, _files.findConfigUpwards)(rootDir);
+        if (upwardRootDir !== null) return upwardRootDir;
+        throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}".\n` + `One of the following config files must be in the directory tree: ` + `"${_files.ROOT_CONFIG_FILENAMES.join(", ")}".`), {
+          code: "BABEL_ROOT_NOT_FOUND",
+          dirname: rootDir
+        });
+      }
+
+    default:
+      throw new Error(`Assertion failure - unknown rootMode value.`);
+  }
+}
+
+function* loadPrivatePartialConfig(inputOpts) {
+  if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
+    throw new Error("Babel options must be an object, null, or undefined");
+  }
+
+  const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
+  const {
+    envName = (0, _environment.getEnv)(),
+    cwd = ".",
+    root: rootDir = ".",
+    rootMode = "root",
+    caller,
+    cloneInputAst = true
+  } = args;
+
+  const absoluteCwd = _path().default.resolve(cwd);
+
+  const absoluteRootDir = yield* resolveRootMode(_path().default.resolve(absoluteCwd, rootDir), rootMode);
+  const filename = typeof args.filename === "string" ? _path().default.resolve(cwd, args.filename) : undefined;
+  const showConfigPath = yield* (0, _files.resolveShowConfigPath)(absoluteCwd);
+  const context = {
+    filename,
+    cwd: absoluteCwd,
+    root: absoluteRootDir,
+    envName,
+    caller,
+    showConfig: showConfigPath === filename
+  };
+  const configChain = yield* (0, _configChain.buildRootChain)(args, context);
+  if (!configChain) return null;
+  const options = {};
+  configChain.options.forEach(opts => {
+    (0, _util.mergeOptions)(options, opts);
+  });
+  options.cloneInputAst = cloneInputAst;
+  options.babelrc = false;
+  options.configFile = false;
+  options.passPerPreset = false;
+  options.envName = context.envName;
+  options.cwd = context.cwd;
+  options.root = context.root;
+  options.filename = typeof context.filename === "string" ? context.filename : undefined;
+  options.plugins = configChain.plugins.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor));
+  options.presets = configChain.presets.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor));
+  return {
+    options,
+    context,
+    fileHandling: configChain.fileHandling,
+    ignore: configChain.ignore,
+    babelrc: configChain.babelrc,
+    config: configChain.config,
+    files: configChain.files
+  };
+}
+
+const loadPartialConfig = (0, _gensync().default)(function* (opts) {
+  let showIgnoredFiles = false;
+
+  if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
+    var _opts = opts;
+    ({
+      showIgnoredFiles
+    } = _opts);
+    opts = _objectWithoutPropertiesLoose(_opts, ["showIgnoredFiles"]);
+    _opts;
+  }
+
+  const result = yield* loadPrivatePartialConfig(opts);
+  if (!result) return null;
+  const {
+    options,
+    babelrc,
+    ignore,
+    config,
+    fileHandling,
+    files
+  } = result;
+
+  if (fileHandling === "ignored" && !showIgnoredFiles) {
+    return null;
+  }
+
+  (options.plugins || []).forEach(item => {
+    if (item.value instanceof _plugin.default) {
+      throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()");
+    }
+  });
+  return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined, fileHandling, files);
+});
+exports.loadPartialConfig = loadPartialConfig;
+
+class PartialConfig {
+  constructor(options, babelrc, ignore, config, fileHandling, files) {
+    this.options = void 0;
+    this.babelrc = void 0;
+    this.babelignore = void 0;
+    this.config = void 0;
+    this.fileHandling = void 0;
+    this.files = void 0;
+    this.options = options;
+    this.babelignore = ignore;
+    this.babelrc = babelrc;
+    this.config = config;
+    this.fileHandling = fileHandling;
+    this.files = files;
+    Object.freeze(this);
+  }
+
+  hasFilesystemConfig() {
+    return this.babelrc !== undefined || this.config !== undefined;
+  }
+
+}
+
+Object.freeze(PartialConfig.prototype);

package/dist/node_modules/@corva/eslint-config-browser/node_modules/@babel/core/lib/config/pattern-to-regex.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = pathToPattern;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _escapeRegExp() {
+  const data = _interopRequireDefault(require("lodash/escapeRegExp"));
+
+  _escapeRegExp = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const sep = `\\${_path().default.sep}`;
+const endSep = `(?:${sep}|$)`;
+const substitution = `[^${sep}]+`;
+const starPat = `(?:${substitution}${sep})`;
+const starPatLast = `(?:${substitution}${endSep})`;
+const starStarPat = `${starPat}*?`;
+const starStarPatLast = `${starPat}*?${starPatLast}?`;
+
+function pathToPattern(pattern, dirname) {
+  const parts = _path().default.resolve(dirname, pattern).split(_path().default.sep);
+
+  return new RegExp(["^", ...parts.map((part, i) => {
+    const last = i === parts.length - 1;
+    if (part === "**") return last ? starStarPatLast : starStarPat;
+    if (part === "*") return last ? starPatLast : starPat;
+
+    if (part.indexOf("*.") === 0) {
+      return substitution + (0, _escapeRegExp().default)(part.slice(1)) + (last ? endSep : sep);
+    }
+
+    return (0, _escapeRegExp().default)(part) + (last ? endSep : sep);
+  })].join(""));
+}

package/dist/node_modules/@corva/eslint-config-browser/node_modules/@babel/core/lib/config/plugin.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Plugin {
+  constructor(plugin, options, key) {
+    this.key = void 0;
+    this.manipulateOptions = void 0;
+    this.post = void 0;
+    this.pre = void 0;
+    this.visitor = void 0;
+    this.parserOverride = void 0;
+    this.generatorOverride = void 0;
+    this.options = void 0;
+    this.key = plugin.name || key;
+    this.manipulateOptions = plugin.manipulateOptions;
+    this.post = plugin.post;
+    this.pre = plugin.pre;
+    this.visitor = plugin.visitor || {};
+    this.parserOverride = plugin.parserOverride;
+    this.generatorOverride = plugin.generatorOverride;
+    this.options = options;
+  }
+
+}
+
+exports.default = Plugin;

package/dist/node_modules/@corva/eslint-config-browser/node_modules/@babel/core/lib/config/printer.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConfigPrinter = exports.ChainFormatter = void 0;
+const ChainFormatter = {
+  Programmatic: 0,
+  Config: 1
+};
+exports.ChainFormatter = ChainFormatter;
+const Formatter = {
+  title(type, callerName, filepath) {
+    let title = "";
+
+    if (type === ChainFormatter.Programmatic) {
+      title = "programmatic options";
+
+      if (callerName) {
+        title += " from " + callerName;
+      }
+    } else {
+      title = "config " + filepath;
+    }
+
+    return title;
+  },
+
+  loc(index, envName) {
+    let loc = "";
+
+    if (index != null) {
+      loc += `.overrides[${index}]`;
+    }
+
+    if (envName != null) {
+      loc += `.env["${envName}"]`;
+    }
+
+    return loc;
+  },
+
+  optionsAndDescriptors(opt) {
+    const content = Object.assign({}, opt.options);
+    delete content.overrides;
+    delete content.env;
+    const pluginDescriptors = [...opt.plugins()];
+
+    if (pluginDescriptors.length) {
+      content.plugins = pluginDescriptors.map(d => descriptorToConfig(d));
+    }
+
+    const presetDescriptors = [...opt.presets()];
+
+    if (presetDescriptors.length) {
+      content.presets = [...presetDescriptors].map(d => descriptorToConfig(d));
+    }
+
+    return JSON.stringify(content, undefined, 2);
+  }
+
+};
+
+function descriptorToConfig(d) {
+  var _d$file;
+
+  let name = (_d$file = d.file) == null ? void 0 : _d$file.request;
+
+  if (name == null) {
+    if (typeof d.value === "object") {
+      name = d.value;
+    } else if (typeof d.value === "function") {
+      name = `[Function: ${d.value.toString().substr(0, 50)} ... ]`;
+    }
+  }
+
+  if (name == null) {
+    name = "[Unknown]";
+  }
+
+  if (d.options === undefined) {
+    return name;
+  } else if (d.name == null) {
+    return [name, d.options];
+  } else {
+    return [name, d.options, d.name];
+  }
+}
+
+class ConfigPrinter {
+  constructor() {
+    this._stack = [];
+  }
+
+  configure(enabled, type, {
+    callerName,
+    filepath
+  }) {
+    if (!enabled) return () => {};
+    return (content, index, envName) => {
+      this._stack.push({
+        type,
+        callerName,
+        filepath,
+        content,
+        index,
+        envName
+      });
+    };
+  }
+
+  static format(config) {
+    let title = Formatter.title(config.type, config.callerName, config.filepath);
+    const loc = Formatter.loc(config.index, config.envName);
+    if (loc) title += ` ${loc}`;
+    const content = Formatter.optionsAndDescriptors(config.content);
+    return `${title}\n${content}`;
+  }
+
+  output() {
+    if (this._stack.length === 0) return "";
+    return this._stack.map(s => ConfigPrinter.format(s)).join("\n\n");
+  }
+
+}
+
+exports.ConfigPrinter = ConfigPrinter;

package/dist/node_modules/@corva/eslint-config-browser/node_modules/@babel/core/lib/config/util.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeOptions = mergeOptions;
+exports.isIterableIterator = isIterableIterator;
+
+function mergeOptions(target, source) {
+  for (const k of Object.keys(source)) {
+    if (k === "parserOpts" && source.parserOpts) {
+      const parserOpts = source.parserOpts;
+      const targetObj = target.parserOpts = target.parserOpts || {};
+      mergeDefaultFields(targetObj, parserOpts);
+    } else if (k === "generatorOpts" && source.generatorOpts) {
+      const generatorOpts = source.generatorOpts;
+      const targetObj = target.generatorOpts = target.generatorOpts || {};
+      mergeDefaultFields(targetObj, generatorOpts);
+    } else {
+      const val = source[k];
+      if (val !== undefined) target[k] = val;
+    }
+  }
+}
+
+function mergeDefaultFields(target, source) {
+  for (const k of Object.keys(source)) {
+    const val = source[k];
+    if (val !== undefined) target[k] = val;
+  }
+}
+
+function isIterableIterator(value) {
+  return !!value && typeof value.next === "function" && typeof value[Symbol.iterator] === "function";
+}

package/dist/node_modules/@corva/eslint-config-browser/node_modules/@babel/core/lib/config/validation/option-assertions.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.msg = msg;
+exports.access = access;
+exports.assertRootMode = assertRootMode;
+exports.assertSourceMaps = assertSourceMaps;
+exports.assertCompact = assertCompact;
+exports.assertSourceType = assertSourceType;
+exports.assertCallerMetadata = assertCallerMetadata;
+exports.assertInputSourceMap = assertInputSourceMap;
+exports.assertString = assertString;
+exports.assertFunction = assertFunction;
+exports.assertBoolean = assertBoolean;
+exports.assertObject = assertObject;
+exports.assertArray = assertArray;
+exports.assertIgnoreList = assertIgnoreList;
+exports.assertConfigApplicableTest = assertConfigApplicableTest;
+exports.assertConfigFileSearch = assertConfigFileSearch;
+exports.assertBabelrcSearch = assertBabelrcSearch;
+exports.assertPluginList = assertPluginList;
+
+function msg(loc) {
+  switch (loc.type) {
+    case "root":
+      return ``;
+
+    case "env":
+      return `${msg(loc.parent)}.env["${loc.name}"]`;
+
+    case "overrides":
+      return `${msg(loc.parent)}.overrides[${loc.index}]`;
+
+    case "option":
+      return `${msg(loc.parent)}.${loc.name}`;
+
+    case "access":
+      return `${msg(loc.parent)}[${JSON.stringify(loc.name)}]`;
+
+    default:
+      throw new Error(`Assertion failure: Unknown type ${loc.type}`);
+  }
+}
+
+function access(loc, name) {
+  return {
+    type: "access",
+    name,
+    parent: loc
+  };
+}
+
+function assertRootMode(loc, value) {
+  if (value !== undefined && value !== "root" && value !== "upward" && value !== "upward-optional") {
+    throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`);
+  }
+
+  return value;
+}
+
+function assertSourceMaps(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {
+    throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`);
+  }
+
+  return value;
+}
+
+function assertCompact(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "auto") {
+    throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`);
+  }
+
+  return value;
+}
+
+function assertSourceType(loc, value) {
+  if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {
+    throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`);
+  }
+
+  return value;
+}
+
+function assertCallerMetadata(loc, value) {
+  const obj = assertObject(loc, value);
+
+  if (obj) {
+    if (typeof obj["name"] !== "string") {
+      throw new Error(`${msg(loc)} set but does not contain "name" property string`);
+    }
+
+    for (const prop of Object.keys(obj)) {
+      const propLoc = access(loc, prop);
+      const value = obj[prop];
+
+      if (value != null && typeof value !== "boolean" && typeof value !== "string" && typeof value !== "number") {
+        throw new Error(`${msg(propLoc)} must be null, undefined, a boolean, a string, or a number.`);
+      }
+    }
+  }
+
+  return value;
+}
+
+function assertInputSourceMap(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {
+    throw new Error(`${msg(loc)} must be a boolean, object, or undefined`);
+  }
+
+  return value;
+}
+
+function assertString(loc, value) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new Error(`${msg(loc)} must be a string, or undefined`);
+  }
+
+  return value;
+}
+
+function assertFunction(loc, value) {
+  if (value !== undefined && typeof value !== "function") {
+    throw new Error(`${msg(loc)} must be a function, or undefined`);
+  }
+
+  return value;
+}
+
+function assertBoolean(loc, value) {
+  if (value !== undefined && typeof value !== "boolean") {
+    throw new Error(`${msg(loc)} must be a boolean, or undefined`);
+  }
+
+  return value;
+}
+
+function assertObject(loc, value) {
+  if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {
+    throw new Error(`${msg(loc)} must be an object, or undefined`);
+  }
+
+  return value;
+}
+
+function assertArray(loc, value) {
+  if (value != null && !Array.isArray(value)) {
+    throw new Error(`${msg(loc)} must be an array, or undefined`);
+  }
+
+  return value;
+}
+
+function assertIgnoreList(loc, value) {
+  const arr = assertArray(loc, value);
+
+  if (arr) {
+    arr.forEach((item, i) => assertIgnoreItem(access(loc, i), item));
+  }
+
+  return arr;
+}
+
+function assertIgnoreItem(loc, value) {
+  if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) {
+    throw new Error(`${msg(loc)} must be an array of string/Function/RegExp values, or undefined`);
+  }
+
+  return value;
+}
+
+function assertConfigApplicableTest(loc, value) {
+  if (value === undefined) return value;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      if (!checkValidTest(item)) {
+        throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
+      }
+    });
+  } else if (!checkValidTest(value)) {
+    throw new Error(`${msg(loc)} must be a string/Function/RegExp, or an array of those`);
+  }
+
+  return value;
+}
+
+function checkValidTest(value) {
+  return typeof value === "string" || typeof value === "function" || value instanceof RegExp;
+}
+
+function assertConfigFileSearch(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
+    throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`);
+  }
+
+  return value;
+}
+
+function assertBabelrcSearch(loc, value) {
+  if (value === undefined || typeof value === "boolean") return value;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      if (!checkValidTest(item)) {
+        throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
+      }
+    });
+  } else if (!checkValidTest(value)) {
+    throw new Error(`${msg(loc)} must be a undefined, a boolean, a string/Function/RegExp ` + `or an array of those, got ${JSON.stringify(value)}`);
+  }
+
+  return value;
+}
+
+function assertPluginList(loc, value) {
+  const arr = assertArray(loc, value);
+
+  if (arr) {
+    arr.forEach((item, i) => assertPluginItem(access(loc, i), item));
+  }
+
+  return arr;
+}
+
+function assertPluginItem(loc, value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error(`${msg(loc)} must include an object`);
+    }
+
+    if (value.length > 3) {
+      throw new Error(`${msg(loc)} may only be a two-tuple or three-tuple`);
+    }
+
+    assertPluginTarget(access(loc, 0), value[0]);
+
+    if (value.length > 1) {
+      const opts = value[1];
+
+      if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts) || opts === null)) {
+        throw new Error(`${msg(access(loc, 1))} must be an object, false, or undefined`);
+      }
+    }
+
+    if (value.length === 3) {
+      const name = value[2];
+
+      if (name !== undefined && typeof name !== "string") {
+        throw new Error(`${msg(access(loc, 2))} must be a string, or undefined`);
+      }
+    }
+  } else {
+    assertPluginTarget(loc, value);
+  }
+
+  return value;
+}
+
+function assertPluginTarget(loc, value) {
+  if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") {
+    throw new Error(`${msg(loc)} must be a string, object, function`);
+  }
+
+  return value;
+}