decidim 0.26.0 → 0.27.0.rc1

data/packages/webpacker/node_modules/@jest/core/build/cli/index.js

@@ -0,0 +1,399 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.runCLI = runCLI;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+
+  _exit = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _rimraf() {
+  const data = _interopRequireDefault(require('rimraf'));
+
+  _rimraf = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _console() {
+  const data = require('@jest/console');
+
+  _console = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestConfig() {
+  const data = require('jest-config');
+
+  _jestConfig = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestRuntime() {
+  const data = _interopRequireDefault(require('jest-runtime'));
+
+  _jestRuntime = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _TestWatcher = _interopRequireDefault(require('../TestWatcher'));
+
+var _collectHandles = require('../collectHandles');
+
+var _getChangedFilesPromise = _interopRequireDefault(
+  require('../getChangedFilesPromise')
+);
+
+var _getConfigsOfProjectsToRun = _interopRequireDefault(
+  require('../getConfigsOfProjectsToRun')
+);
+
+var _getProjectNamesMissingWarning = _interopRequireDefault(
+  require('../getProjectNamesMissingWarning')
+);
+
+var _getSelectProjectsMessage = _interopRequireDefault(
+  require('../getSelectProjectsMessage')
+);
+
+var _createContext = _interopRequireDefault(require('../lib/createContext'));
+
+var _handleDeprecationWarnings = _interopRequireDefault(
+  require('../lib/handleDeprecationWarnings')
+);
+
+var _logDebugMessages = _interopRequireDefault(
+  require('../lib/logDebugMessages')
+);
+
+var _pluralize = _interopRequireDefault(require('../pluralize'));
+
+var _runJest = _interopRequireDefault(require('../runJest'));
+
+var _watch = _interopRequireDefault(require('../watch'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const {print: preRunMessagePrint} = _jestUtil().preRunMessage;
+
+async function runCLI(argv, projects) {
+  let results; // If we output a JSON object, we can't write anything to stdout, since
+  // it'll break the JSON structure and it won't be valid.
+
+  const outputStream =
+    argv.json || argv.useStderr ? process.stderr : process.stdout;
+  const {globalConfig, configs, hasDeprecationWarnings} = await (0,
+  _jestConfig().readConfigs)(argv, projects);
+
+  if (argv.debug) {
+    (0, _logDebugMessages.default)(globalConfig, configs, outputStream);
+  }
+
+  if (argv.showConfig) {
+    (0, _logDebugMessages.default)(globalConfig, configs, process.stdout);
+    (0, _exit().default)(0);
+  }
+
+  if (argv.clearCache) {
+    configs.forEach(config => {
+      _rimraf().default.sync(config.cacheDirectory);
+
+      process.stdout.write(`Cleared ${config.cacheDirectory}\n`);
+    });
+    (0, _exit().default)(0);
+  }
+
+  let configsOfProjectsToRun = configs;
+
+  if (argv.selectProjects) {
+    const namesMissingWarning = (0, _getProjectNamesMissingWarning.default)(
+      configs
+    );
+
+    if (namesMissingWarning) {
+      outputStream.write(namesMissingWarning);
+    }
+
+    configsOfProjectsToRun = (0, _getConfigsOfProjectsToRun.default)(
+      argv.selectProjects,
+      configs
+    );
+    outputStream.write(
+      (0, _getSelectProjectsMessage.default)(configsOfProjectsToRun)
+    );
+  }
+
+  await _run10000(
+    globalConfig,
+    configsOfProjectsToRun,
+    hasDeprecationWarnings,
+    outputStream,
+    r => {
+      results = r;
+    }
+  );
+
+  if (argv.watch || argv.watchAll) {
+    // If in watch mode, return the promise that will never resolve.
+    // If the watch mode is interrupted, watch should handle the process
+    // shutdown.
+    return new Promise(() => {});
+  }
+
+  if (!results) {
+    throw new Error(
+      'AggregatedResult must be present after test run is complete'
+    );
+  }
+
+  const {openHandles} = results;
+
+  if (openHandles && openHandles.length) {
+    const formatted = (0, _collectHandles.formatHandleErrors)(
+      openHandles,
+      configs[0]
+    );
+    const openHandlesString = (0, _pluralize.default)(
+      'open handle',
+      formatted.length,
+      's'
+    );
+    const message =
+      _chalk().default.red(
+        `\nJest has detected the following ${openHandlesString} potentially keeping Jest from exiting:\n\n`
+      ) + formatted.join('\n\n');
+    console.error(message);
+  }
+
+  return {
+    globalConfig,
+    results
+  };
+}
+
+const buildContextsAndHasteMaps = async (
+  configs,
+  globalConfig,
+  outputStream
+) => {
+  const hasteMapInstances = Array(configs.length);
+  const contexts = await Promise.all(
+    configs.map(async (config, index) => {
+      (0, _jestUtil().createDirectory)(config.cacheDirectory);
+
+      const hasteMapInstance = _jestRuntime().default.createHasteMap(config, {
+        console: new (_console().CustomConsole)(outputStream, outputStream),
+        maxWorkers: Math.max(
+          1,
+          Math.floor(globalConfig.maxWorkers / configs.length)
+        ),
+        resetCache: !config.cache,
+        watch: globalConfig.watch || globalConfig.watchAll,
+        watchman: globalConfig.watchman
+      });
+
+      hasteMapInstances[index] = hasteMapInstance;
+      return (0, _createContext.default)(
+        config,
+        await hasteMapInstance.build()
+      );
+    })
+  );
+  return {
+    contexts,
+    hasteMapInstances
+  };
+};
+
+const _run10000 = async (
+  globalConfig,
+  configs,
+  hasDeprecationWarnings,
+  outputStream,
+  onComplete
+) => {
+  // Queries to hg/git can take a while, so we need to start the process
+  // as soon as possible, so by the time we need the result it's already there.
+  const changedFilesPromise = (0, _getChangedFilesPromise.default)(
+    globalConfig,
+    configs
+  ); // Filter may need to do an HTTP call or something similar to setup.
+  // We will wait on an async response from this before using the filter.
+
+  let filter;
+
+  if (globalConfig.filter && !globalConfig.skipFilter) {
+    const rawFilter = require(globalConfig.filter);
+
+    let filterSetupPromise;
+
+    if (rawFilter.setup) {
+      // Wrap filter setup Promise to avoid "uncaught Promise" error.
+      // If an error is returned, we surface it in the return value.
+      filterSetupPromise = (async () => {
+        try {
+          await rawFilter.setup();
+        } catch (err) {
+          return err;
+        }
+
+        return undefined;
+      })();
+    }
+
+    filter = async testPaths => {
+      if (filterSetupPromise) {
+        // Expect an undefined return value unless there was an error.
+        const err = await filterSetupPromise;
+
+        if (err) {
+          throw err;
+        }
+      }
+
+      return rawFilter(testPaths);
+    };
+  }
+
+  const {contexts, hasteMapInstances} = await buildContextsAndHasteMaps(
+    configs,
+    globalConfig,
+    outputStream
+  );
+  globalConfig.watch || globalConfig.watchAll
+    ? await runWatch(
+        contexts,
+        configs,
+        hasDeprecationWarnings,
+        globalConfig,
+        outputStream,
+        hasteMapInstances,
+        filter
+      )
+    : await runWithoutWatch(
+        globalConfig,
+        contexts,
+        outputStream,
+        onComplete,
+        changedFilesPromise,
+        filter
+      );
+};
+
+const runWatch = async (
+  contexts,
+  _configs,
+  hasDeprecationWarnings,
+  globalConfig,
+  outputStream,
+  hasteMapInstances,
+  filter
+) => {
+  if (hasDeprecationWarnings) {
+    try {
+      await (0, _handleDeprecationWarnings.default)(
+        outputStream,
+        process.stdin
+      );
+      return (0, _watch.default)(
+        globalConfig,
+        contexts,
+        outputStream,
+        hasteMapInstances,
+        undefined,
+        undefined,
+        filter
+      );
+    } catch {
+      (0, _exit().default)(0);
+    }
+  }
+
+  return (0, _watch.default)(
+    globalConfig,
+    contexts,
+    outputStream,
+    hasteMapInstances,
+    undefined,
+    undefined,
+    filter
+  );
+};
+
+const runWithoutWatch = async (
+  globalConfig,
+  contexts,
+  outputStream,
+  onComplete,
+  changedFilesPromise,
+  filter
+) => {
+  const startRun = async () => {
+    if (!globalConfig.listTests) {
+      preRunMessagePrint(outputStream);
+    }
+
+    return (0, _runJest.default)({
+      changedFilesPromise,
+      contexts,
+      failedTestsCache: undefined,
+      filter,
+      globalConfig,
+      onComplete,
+      outputStream,
+      startRun,
+      testWatcher: new _TestWatcher.default({
+        isWatchMode: false
+      })
+    });
+  };
+
+  return startRun();
+};

data/packages/webpacker/node_modules/@jest/core/build/collectHandles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+export declare type HandleCollectionResult = () => Promise<Array<Error>>;
+export default function collectHandles(): HandleCollectionResult;
+export declare function formatHandleErrors(errors: Array<Error>, config: Config.ProjectConfig): Array<string>;

data/packages/webpacker/node_modules/@jest/core/build/collectHandles.js

@@ -0,0 +1,269 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = collectHandles;
+exports.formatHandleErrors = formatHandleErrors;
+
+function asyncHooks() {
+  const data = _interopRequireWildcard(require('async_hooks'));
+
+  asyncHooks = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _util() {
+  const data = require('util');
+
+  _util = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _stripAnsi() {
+  const data = _interopRequireDefault(require('strip-ansi'));
+
+  _stripAnsi = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+function stackIsFromUser(stack) {
+  // Either the test file, or something required by it
+  if (stack.includes('Runtime.requireModule')) {
+    return true;
+  } // jest-jasmine it or describe call
+
+  if (stack.includes('asyncJestTest') || stack.includes('asyncJestLifecycle')) {
+    return true;
+  } // An async function call from within circus
+
+  if (stack.includes('callAsyncCircusFn')) {
+    // jest-circus it or describe call
+    return (
+      stack.includes('_callCircusTest') || stack.includes('_callCircusHook')
+    );
+  }
+
+  return false;
+}
+
+const alwaysActive = () => true; // @ts-expect-error: doesn't exist in v10 typings
+
+const hasWeakRef = typeof WeakRef === 'function';
+const asyncSleep = (0, _util().promisify)(setTimeout); // Inspired by https://github.com/mafintosh/why-is-node-running/blob/master/index.js
+// Extracted as we want to format the result ourselves
+
+function collectHandles() {
+  const activeHandles = new Map();
+  const hook = asyncHooks().createHook({
+    destroy(asyncId) {
+      activeHandles.delete(asyncId);
+    },
+
+    init: function initHook(asyncId, type, triggerAsyncId, resource) {
+      // Skip resources that should not generally prevent the process from
+      // exiting, not last a meaningfully long time, or otherwise shouldn't be
+      // tracked.
+      if (
+        type === 'PROMISE' ||
+        type === 'TIMERWRAP' ||
+        type === 'ELDHISTOGRAM' ||
+        type === 'PerformanceObserver' ||
+        type === 'RANDOMBYTESREQUEST' ||
+        type === 'DNSCHANNEL' ||
+        type === 'ZLIB'
+      ) {
+        return;
+      }
+
+      const error = new (_jestUtil().ErrorWithStack)(type, initHook, 100);
+      let fromUser = stackIsFromUser(error.stack || ''); // If the async resource was not directly created by user code, but was
+      // triggered by another async resource from user code, track it and use
+      // the original triggering resource's stack.
+
+      if (!fromUser) {
+        const triggeringHandle = activeHandles.get(triggerAsyncId);
+
+        if (triggeringHandle) {
+          fromUser = true;
+          error.stack = triggeringHandle.error.stack;
+        }
+      }
+
+      if (fromUser) {
+        let isActive;
+
+        if (type === 'Timeout' || type === 'Immediate') {
+          // Timer that supports hasRef (Node v11+)
+          if ('hasRef' in resource) {
+            if (hasWeakRef) {
+              // @ts-expect-error: doesn't exist in v10 typings
+              const ref = new WeakRef(resource);
+
+              isActive = () => {
+                var _ref$deref$hasRef, _ref$deref;
+
+                return (_ref$deref$hasRef =
+                  (_ref$deref = ref.deref()) === null || _ref$deref === void 0
+                    ? void 0
+                    : _ref$deref.hasRef()) !== null &&
+                  _ref$deref$hasRef !== void 0
+                  ? _ref$deref$hasRef
+                  : false;
+              };
+            } else {
+              // @ts-expect-error: doesn't exist in v10 typings
+              isActive = resource.hasRef.bind(resource);
+            }
+          } else {
+            // Timer that doesn't support hasRef
+            isActive = alwaysActive;
+          }
+        } else {
+          // Any other async resource
+          isActive = alwaysActive;
+        }
+
+        activeHandles.set(asyncId, {
+          error,
+          isActive
+        });
+      }
+    }
+  });
+  hook.enable();
+  return async () => {
+    // Wait briefly for any async resources that have been queued for
+    // destruction to actually be destroyed.
+    // For example, Node.js TCP Servers are not destroyed until *after* their
+    // `close` callback runs. If someone finishes a test from the `close`
+    // callback, we will not yet have seen the resource be destroyed here.
+    await asyncSleep(100);
+    hook.disable(); // Get errors for every async resource still referenced at this moment
+
+    const result = Array.from(activeHandles.values())
+      .filter(({isActive}) => isActive())
+      .map(({error}) => error);
+    activeHandles.clear();
+    return result;
+  };
+}
+
+function formatHandleErrors(errors, config) {
+  const stacks = new Set();
+  return (
+    errors
+      .map(err =>
+        (0, _jestMessageUtil().formatExecError)(
+          err,
+          config,
+          {
+            noStackTrace: false
+          },
+          undefined,
+          true
+        )
+      ) // E.g. timeouts might give multiple traces to the same line of code
+      // This hairy filtering tries to remove entries with duplicate stack traces
+      .filter(handle => {
+        const ansiFree = (0, _stripAnsi().default)(handle);
+        const match = ansiFree.match(/\s+at(.*)/);
+
+        if (!match || match.length < 2) {
+          return true;
+        }
+
+        const stack = ansiFree.substr(ansiFree.indexOf(match[1])).trim();
+
+        if (stacks.has(stack)) {
+          return false;
+        }
+
+        stacks.add(stack);
+        return true;
+      })
+  );
+}

data/packages/webpacker/node_modules/@jest/core/build/getChangedFilesPromise.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import { ChangedFilesPromise } from 'jest-changed-files';
+export default function getChangedFilesPromise(globalConfig: Config.GlobalConfig, configs: Array<Config.ProjectConfig>): ChangedFilesPromise | undefined;