decidim 0.26.0 → 0.27.0.rc1

data/packages/webpacker/node_modules/jest-worker/build/Farm.js

@@ -0,0 +1,206 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _FifoQueue = _interopRequireDefault(require('./FifoQueue'));
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class Farm {
+  constructor(_numOfWorkers, _callback, options = {}) {
+    var _options$workerSchedu, _options$taskQueue;
+
+    _defineProperty(this, '_computeWorkerKey', void 0);
+
+    _defineProperty(this, '_workerSchedulingPolicy', void 0);
+
+    _defineProperty(this, '_cacheKeys', Object.create(null));
+
+    _defineProperty(this, '_locks', []);
+
+    _defineProperty(this, '_offset', 0);
+
+    _defineProperty(this, '_taskQueue', void 0);
+
+    this._numOfWorkers = _numOfWorkers;
+    this._callback = _callback;
+    this._computeWorkerKey = options.computeWorkerKey;
+    this._workerSchedulingPolicy =
+      (_options$workerSchedu = options.workerSchedulingPolicy) !== null &&
+      _options$workerSchedu !== void 0
+        ? _options$workerSchedu
+        : 'round-robin';
+    this._taskQueue =
+      (_options$taskQueue = options.taskQueue) !== null &&
+      _options$taskQueue !== void 0
+        ? _options$taskQueue
+        : new _FifoQueue.default();
+  }
+
+  doWork(method, ...args) {
+    const customMessageListeners = new Set();
+
+    const addCustomMessageListener = listener => {
+      customMessageListeners.add(listener);
+      return () => {
+        customMessageListeners.delete(listener);
+      };
+    };
+
+    const onCustomMessage = message => {
+      customMessageListeners.forEach(listener => listener(message));
+    };
+
+    const promise = new Promise( // Bind args to this function so it won't reference to the parent scope.
+      // This prevents a memory leak in v8, because otherwise the function will
+      // retaine args for the closure.
+      ((args, resolve, reject) => {
+        const computeWorkerKey = this._computeWorkerKey;
+        const request = [_types.CHILD_MESSAGE_CALL, false, method, args];
+        let worker = null;
+        let hash = null;
+
+        if (computeWorkerKey) {
+          hash = computeWorkerKey.call(this, method, ...args);
+          worker = hash == null ? null : this._cacheKeys[hash];
+        }
+
+        const onStart = worker => {
+          if (hash != null) {
+            this._cacheKeys[hash] = worker;
+          }
+        };
+
+        const onEnd = (error, result) => {
+          customMessageListeners.clear();
+
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        };
+
+        const task = {
+          onCustomMessage,
+          onEnd,
+          onStart,
+          request
+        };
+
+        if (worker) {
+          this._taskQueue.enqueue(task, worker.getWorkerId());
+
+          this._process(worker.getWorkerId());
+        } else {
+          this._push(task);
+        }
+      }).bind(null, args)
+    );
+    promise.UNSTABLE_onCustomMessage = addCustomMessageListener;
+    return promise;
+  }
+
+  _process(workerId) {
+    if (this._isLocked(workerId)) {
+      return this;
+    }
+
+    const task = this._taskQueue.dequeue(workerId);
+
+    if (!task) {
+      return this;
+    }
+
+    if (task.request[1]) {
+      throw new Error('Queue implementation returned processed task');
+    } // Reference the task object outside so it won't be retained by onEnd,
+    // and other properties of the task object, such as task.request can be
+    // garbage collected.
+
+    const taskOnEnd = task.onEnd;
+
+    const onEnd = (error, result) => {
+      taskOnEnd(error, result);
+
+      this._unlock(workerId);
+
+      this._process(workerId);
+    };
+
+    task.request[1] = true;
+
+    this._lock(workerId);
+
+    this._callback(
+      workerId,
+      task.request,
+      task.onStart,
+      onEnd,
+      task.onCustomMessage
+    );
+
+    return this;
+  }
+
+  _push(task) {
+    this._taskQueue.enqueue(task);
+
+    const offset = this._getNextWorkerOffset();
+
+    for (let i = 0; i < this._numOfWorkers; i++) {
+      this._process((offset + i) % this._numOfWorkers);
+
+      if (task.request[1]) {
+        break;
+      }
+    }
+
+    return this;
+  }
+
+  _getNextWorkerOffset() {
+    switch (this._workerSchedulingPolicy) {
+      case 'in-order':
+        return 0;
+
+      case 'round-robin':
+        return this._offset++;
+    }
+  }
+
+  _lock(workerId) {
+    this._locks[workerId] = true;
+  }
+
+  _unlock(workerId) {
+    this._locks[workerId] = false;
+  }
+
+  _isLocked(workerId) {
+    return this._locks[workerId];
+  }
+}
+
+exports.default = Farm;

data/packages/webpacker/node_modules/jest-worker/build/FifoQueue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { QueueChildMessage, TaskQueue } from './types';
+/**
+ * First-in, First-out task queue that manages a dedicated pool
+ * for each worker as well as a shared queue. The FIFO ordering is guaranteed
+ * across the worker specific and shared queue.
+ */
+export default class FifoQueue implements TaskQueue {
+    private _workerQueues;
+    private _sharedQueue;
+    enqueue(task: QueueChildMessage, workerId?: number): void;
+    dequeue(workerId: number): QueueChildMessage | null;
+}

data/packages/webpacker/node_modules/jest-worker/build/FifoQueue.js

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return 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.
+ */
+
+/**
+ * First-in, First-out task queue that manages a dedicated pool
+ * for each worker as well as a shared queue. The FIFO ordering is guaranteed
+ * across the worker specific and shared queue.
+ */
+class FifoQueue {
+  constructor() {
+    _defineProperty(this, '_workerQueues', []);
+
+    _defineProperty(this, '_sharedQueue', new InternalQueue());
+  }
+
+  enqueue(task, workerId) {
+    if (workerId == null) {
+      this._sharedQueue.enqueue(task);
+
+      return;
+    }
+
+    let workerQueue = this._workerQueues[workerId];
+
+    if (workerQueue == null) {
+      workerQueue = this._workerQueues[workerId] = new InternalQueue();
+    }
+
+    const sharedTop = this._sharedQueue.peekLast();
+
+    const item = {
+      previousSharedTask: sharedTop,
+      task
+    };
+    workerQueue.enqueue(item);
+  }
+
+  dequeue(workerId) {
+    var _this$_workerQueues$w, _workerTop$previousSh, _workerTop$previousSh2;
+
+    const workerTop =
+      (_this$_workerQueues$w = this._workerQueues[workerId]) === null ||
+      _this$_workerQueues$w === void 0
+        ? void 0
+        : _this$_workerQueues$w.peek();
+    const sharedTaskIsProcessed =
+      (_workerTop$previousSh =
+        workerTop === null || workerTop === void 0
+          ? void 0
+          : (_workerTop$previousSh2 = workerTop.previousSharedTask) === null ||
+            _workerTop$previousSh2 === void 0
+          ? void 0
+          : _workerTop$previousSh2.request[1]) !== null &&
+      _workerTop$previousSh !== void 0
+        ? _workerTop$previousSh
+        : true; // Process the top task from the shared queue if
+    // - there's no task in the worker specific queue or
+    // - if the non-worker-specific task after which this worker specifif task
+    //   hasn been queued wasn't processed yet
+
+    if (workerTop != null && sharedTaskIsProcessed) {
+      var _this$_workerQueues$w2,
+        _this$_workerQueues$w3,
+        _this$_workerQueues$w4;
+
+      return (_this$_workerQueues$w2 =
+        (_this$_workerQueues$w3 = this._workerQueues[workerId]) === null ||
+        _this$_workerQueues$w3 === void 0
+          ? void 0
+          : (_this$_workerQueues$w4 = _this$_workerQueues$w3.dequeue()) ===
+              null || _this$_workerQueues$w4 === void 0
+          ? void 0
+          : _this$_workerQueues$w4.task) !== null &&
+        _this$_workerQueues$w2 !== void 0
+        ? _this$_workerQueues$w2
+        : null;
+    }
+
+    return this._sharedQueue.dequeue();
+  }
+}
+
+exports.default = FifoQueue;
+
+/**
+ * FIFO queue for a single worker / shared queue.
+ */
+class InternalQueue {
+  constructor() {
+    _defineProperty(this, '_head', null);
+
+    _defineProperty(this, '_last', null);
+  }
+
+  enqueue(value) {
+    const item = {
+      next: null,
+      value
+    };
+
+    if (this._last == null) {
+      this._head = item;
+    } else {
+      this._last.next = item;
+    }
+
+    this._last = item;
+  }
+
+  dequeue() {
+    if (this._head == null) {
+      return null;
+    }
+
+    const item = this._head;
+    this._head = item.next;
+
+    if (this._head == null) {
+      this._last = null;
+    }
+
+    return item.value;
+  }
+
+  peek() {
+    var _this$_head$value, _this$_head;
+
+    return (_this$_head$value =
+      (_this$_head = this._head) === null || _this$_head === void 0
+        ? void 0
+        : _this$_head.value) !== null && _this$_head$value !== void 0
+      ? _this$_head$value
+      : null;
+  }
+
+  peekLast() {
+    var _this$_last$value, _this$_last;
+
+    return (_this$_last$value =
+      (_this$_last = this._last) === null || _this$_last === void 0
+        ? void 0
+        : _this$_last.value) !== null && _this$_last$value !== void 0
+      ? _this$_last$value
+      : null;
+  }
+}

data/packages/webpacker/node_modules/jest-worker/build/PriorityQueue.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { QueueChildMessage, TaskQueue } from './types';
+export declare type ComputeTaskPriorityCallback = (method: string, ...args: Array<unknown>) => number;
+declare type QueueItem = {
+    task: QueueChildMessage;
+    priority: number;
+};
+/**
+ * Priority queue that processes tasks in natural ordering (lower priority first)
+ * accoridng to the priority computed by the function passed in the constructor.
+ *
+ * FIFO ordering isn't guaranteed for tasks with the same priority.
+ *
+ * Worker specific tasks with the same priority as a non-worker specific task
+ * are always processed first.
+ */
+export default class PriorityQueue implements TaskQueue {
+    private _computePriority;
+    private _queue;
+    private _sharedQueue;
+    constructor(_computePriority: ComputeTaskPriorityCallback);
+    enqueue(task: QueueChildMessage, workerId?: number): void;
+    _enqueue(task: QueueChildMessage, queue: MinHeap<QueueItem>): void;
+    dequeue(workerId: number): QueueChildMessage | null;
+    _getWorkerQueue(workerId: number): MinHeap<QueueItem>;
+}
+declare type HeapItem = {
+    priority: number;
+};
+declare class MinHeap<TItem extends HeapItem> {
+    private _heap;
+    peek(): TItem | null;
+    add(item: TItem): void;
+    poll(): TItem | null;
+}
+export {};

data/packages/webpacker/node_modules/jest-worker/build/PriorityQueue.js

@@ -0,0 +1,188 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return 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.
+ */
+
+/**
+ * Priority queue that processes tasks in natural ordering (lower priority first)
+ * accoridng to the priority computed by the function passed in the constructor.
+ *
+ * FIFO ordering isn't guaranteed for tasks with the same priority.
+ *
+ * Worker specific tasks with the same priority as a non-worker specific task
+ * are always processed first.
+ */
+class PriorityQueue {
+  constructor(_computePriority) {
+    _defineProperty(this, '_queue', []);
+
+    _defineProperty(this, '_sharedQueue', new MinHeap());
+
+    this._computePriority = _computePriority;
+  }
+
+  enqueue(task, workerId) {
+    if (workerId == null) {
+      this._enqueue(task, this._sharedQueue);
+    } else {
+      const queue = this._getWorkerQueue(workerId);
+
+      this._enqueue(task, queue);
+    }
+  }
+
+  _enqueue(task, queue) {
+    const item = {
+      priority: this._computePriority(task.request[2], ...task.request[3]),
+      task
+    };
+    queue.add(item);
+  }
+
+  dequeue(workerId) {
+    const workerQueue = this._getWorkerQueue(workerId);
+
+    const workerTop = workerQueue.peek();
+
+    const sharedTop = this._sharedQueue.peek(); // use the task from the worker queue if there's no task in the shared queue
+    // or if the priority of the worker queue is smaller or equal to the
+    // priority of the top task in the shared queue. The tasks of the
+    // worker specific queue are preferred because no other worker can pick this
+    // specific task up.
+
+    if (
+      sharedTop == null ||
+      (workerTop != null && workerTop.priority <= sharedTop.priority)
+    ) {
+      var _workerQueue$poll$tas, _workerQueue$poll;
+
+      return (_workerQueue$poll$tas =
+        (_workerQueue$poll = workerQueue.poll()) === null ||
+        _workerQueue$poll === void 0
+          ? void 0
+          : _workerQueue$poll.task) !== null && _workerQueue$poll$tas !== void 0
+        ? _workerQueue$poll$tas
+        : null;
+    }
+
+    return this._sharedQueue.poll().task;
+  }
+
+  _getWorkerQueue(workerId) {
+    let queue = this._queue[workerId];
+
+    if (queue == null) {
+      queue = this._queue[workerId] = new MinHeap();
+    }
+
+    return queue;
+  }
+}
+
+exports.default = PriorityQueue;
+
+class MinHeap {
+  constructor() {
+    _defineProperty(this, '_heap', []);
+  }
+
+  peek() {
+    var _this$_heap$;
+
+    return (_this$_heap$ = this._heap[0]) !== null && _this$_heap$ !== void 0
+      ? _this$_heap$
+      : null;
+  }
+
+  add(item) {
+    const nodes = this._heap;
+    nodes.push(item);
+
+    if (nodes.length === 1) {
+      return;
+    }
+
+    let currentIndex = nodes.length - 1; // Bubble up the added node as long as the parent is bigger
+
+    while (currentIndex > 0) {
+      const parentIndex = Math.floor((currentIndex + 1) / 2) - 1;
+      const parent = nodes[parentIndex];
+
+      if (parent.priority <= item.priority) {
+        break;
+      }
+
+      nodes[currentIndex] = parent;
+      nodes[parentIndex] = item;
+      currentIndex = parentIndex;
+    }
+  }
+
+  poll() {
+    const nodes = this._heap;
+    const result = nodes[0];
+    const lastElement = nodes.pop(); // heap was empty or removed the last element
+
+    if (result == null || nodes.length === 0) {
+      return result !== null && result !== void 0 ? result : null;
+    }
+
+    let index = 0;
+    nodes[0] =
+      lastElement !== null && lastElement !== void 0 ? lastElement : null;
+    const element = nodes[0];
+
+    while (true) {
+      let swapIndex = null;
+      const rightChildIndex = (index + 1) * 2;
+      const leftChildIndex = rightChildIndex - 1;
+      const rightChild = nodes[rightChildIndex];
+      const leftChild = nodes[leftChildIndex]; // if the left child is smaller, swap with the left
+
+      if (leftChild != null && leftChild.priority < element.priority) {
+        swapIndex = leftChildIndex;
+      } // If the right child is smaller or the right child is smaller than the left
+      // then swap with the right child
+
+      if (
+        rightChild != null &&
+        rightChild.priority < (swapIndex == null ? element : leftChild).priority
+      ) {
+        swapIndex = rightChildIndex;
+      }
+
+      if (swapIndex == null) {
+        break;
+      }
+
+      nodes[index] = nodes[swapIndex];
+      nodes[swapIndex] = element;
+      index = swapIndex;
+    }
+
+    return result;
+  }
+}

data/packages/webpacker/node_modules/jest-worker/build/WorkerPool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 BaseWorkerPool from './base/BaseWorkerPool';
+import type { ChildMessage, OnCustomMessage, OnEnd, OnStart, WorkerInterface, WorkerOptions, WorkerPoolInterface } from './types';
+declare class WorkerPool extends BaseWorkerPool implements WorkerPoolInterface {
+    send(workerId: number, request: ChildMessage, onStart: OnStart, onEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    createWorker(workerOptions: WorkerOptions): WorkerInterface;
+}
+export default WorkerPool;

data/packages/webpacker/node_modules/jest-worker/build/WorkerPool.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _BaseWorkerPool = _interopRequireDefault(require('./base/BaseWorkerPool'));
+
+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 canUseWorkerThreads = () => {
+  try {
+    require('worker_threads');
+
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+class WorkerPool extends _BaseWorkerPool.default {
+  send(workerId, request, onStart, onEnd, onCustomMessage) {
+    this.getWorkerById(workerId).send(request, onStart, onEnd, onCustomMessage);
+  }
+
+  createWorker(workerOptions) {
+    let Worker;
+
+    if (this._options.enableWorkerThreads && canUseWorkerThreads()) {
+      Worker = require('./workers/NodeThreadsWorker').default;
+    } else {
+      Worker = require('./workers/ChildProcessWorker').default;
+    }
+
+    return new Worker(workerOptions);
+  }
+}
+
+var _default = WorkerPool;
+exports.default = _default;

data/packages/webpacker/node_modules/jest-worker/build/base/BaseWorkerPool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+import { PoolExitResult, WorkerInterface, WorkerOptions, WorkerPoolOptions } from '../types';
+export default class BaseWorkerPool {
+    private readonly _stderr;
+    private readonly _stdout;
+    protected readonly _options: WorkerPoolOptions;
+    private readonly _workers;
+    constructor(workerPath: string, options: WorkerPoolOptions);
+    getStderr(): NodeJS.ReadableStream;
+    getStdout(): NodeJS.ReadableStream;
+    getWorkers(): Array<WorkerInterface>;
+    getWorkerById(workerId: number): WorkerInterface;
+    createWorker(_workerOptions: WorkerOptions): WorkerInterface;
+    end(): Promise<PoolExitResult>;
+}