decidim 0.26.2 → 0.26.4

data/packages/webpacker/node_modules/jest-jasmine2/build/types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 type { AssertionError } from 'assert';
+import type { Config } from '@jest/types';
+import expect = require('expect');
+import type CallTracker from './jasmine/CallTracker';
+import type Env from './jasmine/Env';
+import type JsApiReporter from './jasmine/JsApiReporter';
+import type ReportDispatcher from './jasmine/ReportDispatcher';
+import type { default as Spec, SpecResult } from './jasmine/Spec';
+import type SpyStrategy from './jasmine/SpyStrategy';
+import type { default as Suite, SuiteResult } from './jasmine/Suite';
+import type Timer from './jasmine/Timer';
+import type createSpy from './jasmine/createSpy';
+import type SpyRegistry from './jasmine/spyRegistry';
+export declare type SpecDefinitionsFn = () => void;
+export interface AssertionErrorWithStack extends AssertionError {
+    stack: string;
+}
+export declare type SyncExpectationResult = {
+    pass: boolean;
+    message: () => string;
+};
+export declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
+export declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+export declare type RawMatcherFn = (expected: unknown, actual: unknown, options?: unknown) => ExpectationResult;
+export declare type RunDetails = {
+    totalSpecsDefined?: number;
+    failedExpectations?: SuiteResult['failedExpectations'];
+};
+export declare type Reporter = {
+    jasmineDone: (runDetails: RunDetails) => void;
+    jasmineStarted: (runDetails: RunDetails) => void;
+    specDone: (result: SpecResult) => void;
+    specStarted: (spec: SpecResult) => void;
+    suiteDone: (result: SuiteResult) => void;
+    suiteStarted: (result: SuiteResult) => void;
+};
+export interface Spy extends Record<string, any> {
+    (this: Record<string, unknown>, ...args: Array<any>): unknown;
+    and: SpyStrategy;
+    calls: CallTracker;
+    restoreObjectToOriginalState?: () => void;
+}
+declare type JasmineMatcher = {
+    (matchersUtil: unknown, context: unknown): JasmineMatcher;
+    compare: () => RawMatcherFn;
+    negativeCompare: () => RawMatcherFn;
+};
+export declare type JasmineMatchersObject = {
+    [id: string]: JasmineMatcher;
+};
+export declare type Jasmine = {
+    _DEFAULT_TIMEOUT_INTERVAL: number;
+    DEFAULT_TIMEOUT_INTERVAL: number;
+    currentEnv_: ReturnType<typeof Env>['prototype'];
+    getEnv: () => ReturnType<typeof Env>['prototype'];
+    createSpy: typeof createSpy;
+    Env: ReturnType<typeof Env>;
+    JsApiReporter: typeof JsApiReporter;
+    ReportDispatcher: typeof ReportDispatcher;
+    Spec: typeof Spec;
+    SpyRegistry: typeof SpyRegistry;
+    Suite: typeof Suite;
+    Timer: typeof Timer;
+    version: string;
+    testPath: Config.Path;
+    addMatchers: (matchers: JasmineMatchersObject) => void;
+} & typeof expect & typeof globalThis;
+declare global {
+    namespace NodeJS {
+        interface Global {
+            expect: typeof expect;
+        }
+    }
+}
+export {};

data/packages/webpacker/node_modules/jest-jasmine2/build/types.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var _expect = _interopRequireDefault(require('expect'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}

data/packages/webpacker/node_modules/jest-jasmine2/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "jest-jasmine2",
+  "version": "27.5.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-jasmine2"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@jest/environment": "^27.5.1",
+    "@jest/source-map": "^27.5.1",
+    "@jest/test-result": "^27.5.1",
+    "@jest/types": "^27.5.1",
+    "@types/node": "*",
+    "chalk": "^4.0.0",
+    "co": "^4.6.0",
+    "expect": "^27.5.1",
+    "is-generator-fn": "^2.0.0",
+    "jest-each": "^27.5.1",
+    "jest-matcher-utils": "^27.5.1",
+    "jest-message-util": "^27.5.1",
+    "jest-runtime": "^27.5.1",
+    "jest-snapshot": "^27.5.1",
+    "jest-util": "^27.5.1",
+    "pretty-format": "^27.5.1",
+    "throat": "^6.0.1"
+  },
+  "devDependencies": {
+    "@types/co": "^4.6.2"
+  },
+  "engines": {
+    "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "67c1aa20c5fec31366d733e901fee2b981cb1850"
+}

data/packages/webpacker/node_modules/jest-leak-detector/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/packages/webpacker/node_modules/jest-leak-detector/README.md

@@ -0,0 +1,27 @@
+# jest-leak-detector
+
+Module for verifying whether an object has been garbage collected or not.
+
+Internally creates a weak reference to the object, and forces garbage collection to happen. If the reference is gone, it meant no one else was pointing to the object.
+
+## Example
+
+```javascript
+(async function () {
+  let reference = {};
+  let isLeaking;
+
+  const detector = new LeakDetector(reference);
+
+  // Reference is held in memory.
+  isLeaking = await detector.isLeaking();
+  console.log(isLeaking); // true
+
+  // We destroy the only reference to the object.
+  reference = null;
+
+  // Reference is gone.
+  isLeaking = await detector.isLeaking();
+  console.log(isLeaking); // false
+})();
+```

data/packages/webpacker/node_modules/jest-leak-detector/build/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+export default class LeakDetector {
+    private _isReferenceBeingHeld;
+    constructor(value: unknown);
+    isLeaking(): Promise<boolean>;
+    private _runGarbageCollector;
+}

data/packages/webpacker/node_modules/jest-leak-detector/build/index.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _util() {
+  const data = require('util');
+
+  _util = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _v() {
+  const data = require('v8');
+
+  _v = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _vm() {
+  const data = require('vm');
+
+  _vm = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestGetType() {
+  const data = require('jest-get-type');
+
+  _jestGetType = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _prettyFormat() {
+  const data = require('pretty-format');
+
+  _prettyFormat = function () {
+    return data;
+  };
+
+  return data;
+}
+
+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;
+}
+
+const tick = (0, _util().promisify)(setImmediate);
+
+class LeakDetector {
+  constructor(value) {
+    _defineProperty(this, '_isReferenceBeingHeld', void 0);
+
+    if ((0, _jestGetType().isPrimitive)(value)) {
+      throw new TypeError(
+        [
+          'Primitives cannot leak memory.',
+          'You passed a ' +
+            typeof value +
+            ': <' +
+            (0, _prettyFormat().format)(value) +
+            '>'
+        ].join(' ')
+      );
+    }
+
+    let weak;
+
+    try {
+      // eslint-disable-next-line import/no-extraneous-dependencies
+      weak = require('weak-napi');
+    } catch (err) {
+      if (!err || err.code !== 'MODULE_NOT_FOUND') {
+        throw err;
+      }
+
+      throw new Error(
+        'The leaking detection mechanism requires the "weak-napi" package to be installed and work. ' +
+          'Please install it as a dependency on your main project'
+      );
+    }
+
+    weak(value, () => (this._isReferenceBeingHeld = false));
+    this._isReferenceBeingHeld = true; // Ensure value is not leaked by the closure created by the "weak" callback.
+
+    value = null;
+  }
+
+  async isLeaking() {
+    this._runGarbageCollector(); // wait some ticks to allow GC to run properly, see https://github.com/nodejs/node/issues/34636#issuecomment-669366235
+
+    for (let i = 0; i < 10; i++) {
+      await tick();
+    }
+
+    return this._isReferenceBeingHeld;
+  }
+
+  _runGarbageCollector() {
+    const isGarbageCollectorHidden = !global.gc; // GC is usually hidden, so we have to expose it before running.
+
+    (0, _v().setFlagsFromString)('--expose-gc');
+    (0, _vm().runInNewContext)('gc')(); // The GC was not initially exposed, so let's hide it again.
+
+    if (isGarbageCollectorHidden) {
+      (0, _v().setFlagsFromString)('--no-expose-gc');
+    }
+  }
+}
+
+exports.default = LeakDetector;

data/packages/webpacker/node_modules/jest-leak-detector/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "jest-leak-detector",
+  "version": "27.5.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-leak-detector"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "jest-get-type": "^27.5.1",
+    "pretty-format": "^27.5.1"
+  },
+  "devDependencies": {
+    "@types/weak-napi": "^2.0.0",
+    "weak-napi": "^2.0.1"
+  },
+  "engines": {
+    "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "67c1aa20c5fec31366d733e901fee2b981cb1850"
+}

data/packages/webpacker/node_modules/jest-matcher-utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/packages/webpacker/node_modules/jest-matcher-utils/README.md

@@ -0,0 +1,24 @@
+# jest-matcher-utils
+
+This package's exports are most notably used by `expect`'s [`this.utils`](https://jestjs.io/docs/expect#thisutils).
+
+## Installation
+
+To add this package as a dependency of a project, run either of the following commands:
+
+- `npm install jest-matcher-utils`
+- `yarn add jest-matcher-utils`
+
+## Exports ([src/index.ts](https://github.com/facebook/jest/blob/HEAD/packages/jest-matcher-utils/src/index.ts))
+
+### Functions
+
+`stringify` `highlightTrailingWhitespace` `printReceived` `printExpected` `printWithType` `ensureNoExpected` `ensureActualIsNumber` `ensureExpectedIsNumber` `ensureNumbers` `ensureExpectedIsNonNegativeInteger` `printDiffOrStringify` `diff` `pluralize` `getLabelPrinter` `matcherErrorMessage` `matcherHint`
+
+### Types
+
+`MatcherHintOptions` `DiffOptions`
+
+### Constants
+
+`EXPECTED_COLOR` `RECEIVED_COLOR` `INVERTED_COLOR` `BOLD_WEIGHT` `DIM_COLOR` `SUGGEST_TO_CONTAIN_EQUAL`

data/packages/webpacker/node_modules/jest-matcher-utils/build/Replaceable.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+declare type ReplaceableForEachCallBack = (value: unknown, key: unknown, object: unknown) => void;
+export default class Replaceable {
+    object: any;
+    type: string;
+    constructor(object: any);
+    static isReplaceable(obj1: unknown, obj2: unknown): boolean;
+    forEach(cb: ReplaceableForEachCallBack): void;
+    get(key: any): any;
+    set(key: any, value: any): void;
+}
+export {};

data/packages/webpacker/node_modules/jest-matcher-utils/build/Replaceable.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _jestGetType = require('jest-get-type');
+
+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;
+}
+
+const supportTypes = ['map', 'array', 'object'];
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+class Replaceable {
+  constructor(object) {
+    _defineProperty(this, 'object', void 0);
+
+    _defineProperty(this, 'type', void 0);
+
+    this.object = object;
+    this.type = (0, _jestGetType.getType)(object);
+
+    if (!supportTypes.includes(this.type)) {
+      throw new Error(`Type ${this.type} is not support in Replaceable!`);
+    }
+  }
+
+  static isReplaceable(obj1, obj2) {
+    const obj1Type = (0, _jestGetType.getType)(obj1);
+    const obj2Type = (0, _jestGetType.getType)(obj2);
+    return obj1Type === obj2Type && supportTypes.includes(obj1Type);
+  }
+
+  forEach(cb) {
+    if (this.type === 'object') {
+      const descriptors = Object.getOwnPropertyDescriptors(this.object);
+      [
+        ...Object.keys(descriptors),
+        ...Object.getOwnPropertySymbols(descriptors)
+      ] //@ts-expect-error because typescript do not support symbol key in object
+        //https://github.com/microsoft/TypeScript/issues/1863
+        .filter(key => descriptors[key].enumerable)
+        .forEach(key => {
+          cb(this.object[key], key, this.object);
+        });
+    } else {
+      this.object.forEach(cb);
+    }
+  }
+
+  get(key) {
+    if (this.type === 'map') {
+      return this.object.get(key);
+    }
+
+    return this.object[key];
+  }
+
+  set(key, value) {
+    if (this.type === 'map') {
+      this.object.set(key, value);
+    } else {
+      this.object[key] = value;
+    }
+  }
+}
+/* eslint-enable */
+
+exports.default = Replaceable;

data/packages/webpacker/node_modules/jest-matcher-utils/build/deepCyclicCopyReplaceable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export default function deepCyclicCopyReplaceable<T>(value: T, cycles?: WeakMap<any, any>): T;

data/packages/webpacker/node_modules/jest-matcher-utils/build/deepCyclicCopyReplaceable.js

@@ -0,0 +1,110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = deepCyclicCopyReplaceable;
+
+var _prettyFormat = require('pretty-format');
+
+/**
+ * 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 builtInObject = [
+  Array,
+  Date,
+  Float32Array,
+  Float64Array,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  Map,
+  Set,
+  RegExp,
+  Uint16Array,
+  Uint32Array,
+  Uint8Array,
+  Uint8ClampedArray
+];
+
+if (typeof Buffer !== 'undefined') {
+  builtInObject.push(Buffer);
+}
+
+const isBuiltInObject = object => builtInObject.includes(object.constructor);
+
+const isMap = value => value.constructor === Map;
+
+function deepCyclicCopyReplaceable(value, cycles = new WeakMap()) {
+  if (typeof value !== 'object' || value === null) {
+    return value;
+  } else if (cycles.has(value)) {
+    return cycles.get(value);
+  } else if (Array.isArray(value)) {
+    return deepCyclicCopyArray(value, cycles);
+  } else if (isMap(value)) {
+    return deepCyclicCopyMap(value, cycles);
+  } else if (isBuiltInObject(value)) {
+    return value;
+  } else if (_prettyFormat.plugins.DOMElement.test(value)) {
+    return value.cloneNode(true);
+  } else {
+    return deepCyclicCopyObject(value, cycles);
+  }
+}
+
+function deepCyclicCopyObject(object, cycles) {
+  const newObject = Object.create(Object.getPrototypeOf(object));
+  const descriptors = Object.getOwnPropertyDescriptors(object);
+  cycles.set(object, newObject);
+  const newDescriptors = [
+    ...Object.keys(descriptors),
+    ...Object.getOwnPropertySymbols(descriptors)
+  ].reduce(
+    //@ts-expect-error because typescript do not support symbol key in object
+    //https://github.com/microsoft/TypeScript/issues/1863
+    (newDescriptors, key) => {
+      const enumerable = descriptors[key].enumerable;
+      newDescriptors[key] = {
+        configurable: true,
+        enumerable,
+        value: deepCyclicCopyReplaceable(
+          // this accesses the value or getter, depending. We just care about the value anyways, and this allows us to not mess with accessors
+          // it has the side effect of invoking the getter here though, rather than copying it over
+          object[key],
+          cycles
+        ),
+        writable: true
+      };
+      return newDescriptors;
+    },
+    {}
+  ); //@ts-expect-error because typescript do not support symbol key in object
+  //https://github.com/microsoft/TypeScript/issues/1863
+
+  return Object.defineProperties(newObject, newDescriptors);
+}
+
+function deepCyclicCopyArray(array, cycles) {
+  const newArray = new (Object.getPrototypeOf(array).constructor)(array.length);
+  const length = array.length;
+  cycles.set(array, newArray);
+
+  for (let i = 0; i < length; i++) {
+    newArray[i] = deepCyclicCopyReplaceable(array[i], cycles);
+  }
+
+  return newArray;
+}
+
+function deepCyclicCopyMap(map, cycles) {
+  const newMap = new Map();
+  cycles.set(map, newMap);
+  map.forEach((value, key) => {
+    newMap.set(key, deepCyclicCopyReplaceable(value, cycles));
+  });
+  return newMap;
+}