decidim 0.26.2 → 0.26.4

data/packages/webpacker/node_modules/expect/build/asymmetricMatchers.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 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 { AsymmetricMatcher as AsymmetricMatcherInterface, MatcherState } from './types';
+export declare abstract class AsymmetricMatcher<T, State extends MatcherState = MatcherState> implements AsymmetricMatcherInterface {
+    protected sample: T;
+    protected inverse: boolean;
+    $$typeof: symbol;
+    constructor(sample: T, inverse?: boolean);
+    protected getMatcherContext(): State;
+    abstract asymmetricMatch(other: unknown): boolean;
+    abstract toString(): string;
+    getExpectedType?(): string;
+    toAsymmetricMatcher?(): string;
+}
+declare class Any extends AsymmetricMatcher<any> {
+    constructor(sample: unknown);
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    getExpectedType(): string;
+    toAsymmetricMatcher(): string;
+}
+declare class Anything extends AsymmetricMatcher<void> {
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    toAsymmetricMatcher(): string;
+}
+declare class ArrayContaining extends AsymmetricMatcher<Array<unknown>> {
+    constructor(sample: Array<unknown>, inverse?: boolean);
+    asymmetricMatch(other: Array<unknown>): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class ObjectContaining extends AsymmetricMatcher<Record<string, unknown>> {
+    constructor(sample: Record<string, unknown>, inverse?: boolean);
+    asymmetricMatch(other: any): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class StringContaining extends AsymmetricMatcher<string> {
+    constructor(sample: string, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(sample: string | RegExp, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class CloseTo extends AsymmetricMatcher<number> {
+    private precision;
+    constructor(sample: number, precision?: number, inverse?: boolean);
+    asymmetricMatch(other: number): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+export declare const any: (expectedObject: unknown) => Any;
+export declare const anything: () => Anything;
+export declare const arrayContaining: (sample: Array<unknown>) => ArrayContaining;
+export declare const arrayNotContaining: (sample: Array<unknown>) => ArrayContaining;
+export declare const objectContaining: (sample: Record<string, unknown>) => ObjectContaining;
+export declare const objectNotContaining: (sample: Record<string, unknown>) => ObjectContaining;
+export declare const stringContaining: (expected: string) => StringContaining;
+export declare const stringNotContaining: (expected: string) => StringContaining;
+export declare const stringMatching: (expected: string | RegExp) => StringMatching;
+export declare const stringNotMatching: (expected: string | RegExp) => StringMatching;
+export declare const closeTo: (expected: number, precision?: number | undefined) => CloseTo;
+export declare const notCloseTo: (expected: number, precision?: number | undefined) => CloseTo;
+export {};

data/packages/webpacker/node_modules/expect/build/asymmetricMatchers.js

@@ -0,0 +1,432 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.stringNotMatching =
+  exports.stringNotContaining =
+  exports.stringMatching =
+  exports.stringContaining =
+  exports.objectNotContaining =
+  exports.objectContaining =
+  exports.notCloseTo =
+  exports.closeTo =
+  exports.arrayNotContaining =
+  exports.arrayContaining =
+  exports.anything =
+  exports.any =
+  exports.AsymmetricMatcher =
+    void 0;
+
+var matcherUtils = _interopRequireWildcard(require('jest-matcher-utils'));
+
+var _jasmineUtils = require('./jasmineUtils');
+
+var _jestMatchersObject = require('./jestMatchersObject');
+
+var _utils = require('./utils');
+
+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;
+}
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+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 utils = Object.freeze({
+  ...matcherUtils,
+  iterableEquality: _utils.iterableEquality,
+  subsetEquality: _utils.subsetEquality
+});
+
+class AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    _defineProperty(this, '$$typeof', Symbol.for('jest.asymmetricMatcher'));
+
+    this.sample = sample;
+    this.inverse = inverse;
+  }
+
+  getMatcherContext() {
+    return {
+      ...(0, _jestMatchersObject.getState)(),
+      equals: _jasmineUtils.equals,
+      isNot: this.inverse,
+      utils
+    };
+  }
+}
+
+exports.AsymmetricMatcher = AsymmetricMatcher;
+
+class Any extends AsymmetricMatcher {
+  constructor(sample) {
+    if (typeof sample === 'undefined') {
+      throw new TypeError(
+        'any() expects to be passed a constructor function. ' +
+          'Please pass one or use anything() to match any object.'
+      );
+    }
+
+    super(sample);
+  }
+
+  asymmetricMatch(other) {
+    if (this.sample == String) {
+      return typeof other == 'string' || other instanceof String;
+    }
+
+    if (this.sample == Number) {
+      return typeof other == 'number' || other instanceof Number;
+    }
+
+    if (this.sample == Function) {
+      return typeof other == 'function' || other instanceof Function;
+    }
+
+    if (this.sample == Boolean) {
+      return typeof other == 'boolean' || other instanceof Boolean;
+    }
+
+    if (this.sample == BigInt) {
+      return typeof other == 'bigint' || other instanceof BigInt;
+    }
+
+    if (this.sample == Symbol) {
+      return typeof other == 'symbol' || other instanceof Symbol;
+    }
+
+    if (this.sample == Object) {
+      return typeof other == 'object';
+    }
+
+    return other instanceof this.sample;
+  }
+
+  toString() {
+    return 'Any';
+  }
+
+  getExpectedType() {
+    if (this.sample == String) {
+      return 'string';
+    }
+
+    if (this.sample == Number) {
+      return 'number';
+    }
+
+    if (this.sample == Function) {
+      return 'function';
+    }
+
+    if (this.sample == Object) {
+      return 'object';
+    }
+
+    if (this.sample == Boolean) {
+      return 'boolean';
+    }
+
+    return (0, _jasmineUtils.fnNameFor)(this.sample);
+  }
+
+  toAsymmetricMatcher() {
+    return 'Any<' + (0, _jasmineUtils.fnNameFor)(this.sample) + '>';
+  }
+}
+
+class Anything extends AsymmetricMatcher {
+  asymmetricMatch(other) {
+    return !(0, _jasmineUtils.isUndefined)(other) && other !== null;
+  }
+
+  toString() {
+    return 'Anything';
+  } // No getExpectedType method, because it matches either null or undefined.
+
+  toAsymmetricMatcher() {
+    return 'Anything';
+  }
+}
+
+class ArrayContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+
+  asymmetricMatch(other) {
+    if (!Array.isArray(this.sample)) {
+      throw new Error(
+        `You must provide an array to ${this.toString()}, not '` +
+          typeof this.sample +
+          "'."
+      );
+    }
+
+    const result =
+      this.sample.length === 0 ||
+      (Array.isArray(other) &&
+        this.sample.every(item =>
+          other.some(another => (0, _jasmineUtils.equals)(item, another))
+        ));
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `Array${this.inverse ? 'Not' : ''}Containing`;
+  }
+
+  getExpectedType() {
+    return 'array';
+  }
+}
+
+class ObjectContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+
+  asymmetricMatch(other) {
+    if (typeof this.sample !== 'object') {
+      throw new Error(
+        `You must provide an object to ${this.toString()}, not '` +
+          typeof this.sample +
+          "'."
+      );
+    }
+
+    let result = true;
+
+    for (const property in this.sample) {
+      if (
+        !(0, _jasmineUtils.hasProperty)(other, property) ||
+        !(0, _jasmineUtils.equals)(this.sample[property], other[property])
+      ) {
+        result = false;
+        break;
+      }
+    }
+
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `Object${this.inverse ? 'Not' : ''}Containing`;
+  }
+
+  getExpectedType() {
+    return 'object';
+  }
+}
+
+class StringContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    if (!(0, _jasmineUtils.isA)('String', sample)) {
+      throw new Error('Expected is not a string');
+    }
+
+    super(sample, inverse);
+  }
+
+  asymmetricMatch(other) {
+    const result =
+      (0, _jasmineUtils.isA)('String', other) && other.includes(this.sample);
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `String${this.inverse ? 'Not' : ''}Containing`;
+  }
+
+  getExpectedType() {
+    return 'string';
+  }
+}
+
+class StringMatching extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    if (
+      !(0, _jasmineUtils.isA)('String', sample) &&
+      !(0, _jasmineUtils.isA)('RegExp', sample)
+    ) {
+      throw new Error('Expected is not a String or a RegExp');
+    }
+
+    super(new RegExp(sample), inverse);
+  }
+
+  asymmetricMatch(other) {
+    const result =
+      (0, _jasmineUtils.isA)('String', other) && this.sample.test(other);
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `String${this.inverse ? 'Not' : ''}Matching`;
+  }
+
+  getExpectedType() {
+    return 'string';
+  }
+}
+
+class CloseTo extends AsymmetricMatcher {
+  constructor(sample, precision = 2, inverse = false) {
+    if (!(0, _jasmineUtils.isA)('Number', sample)) {
+      throw new Error('Expected is not a Number');
+    }
+
+    if (!(0, _jasmineUtils.isA)('Number', precision)) {
+      throw new Error('Precision is not a Number');
+    }
+
+    super(sample);
+
+    _defineProperty(this, 'precision', void 0);
+
+    this.inverse = inverse;
+    this.precision = precision;
+  }
+
+  asymmetricMatch(other) {
+    if (!(0, _jasmineUtils.isA)('Number', other)) {
+      return false;
+    }
+
+    let result = false;
+
+    if (other === Infinity && this.sample === Infinity) {
+      result = true; // Infinity - Infinity is NaN
+    } else if (other === -Infinity && this.sample === -Infinity) {
+      result = true; // -Infinity - -Infinity is NaN
+    } else {
+      result =
+        Math.abs(this.sample - other) < Math.pow(10, -this.precision) / 2;
+    }
+
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `Number${this.inverse ? 'Not' : ''}CloseTo`;
+  }
+
+  getExpectedType() {
+    return 'number';
+  }
+}
+
+const any = expectedObject => new Any(expectedObject);
+
+exports.any = any;
+
+const anything = () => new Anything();
+
+exports.anything = anything;
+
+const arrayContaining = sample => new ArrayContaining(sample);
+
+exports.arrayContaining = arrayContaining;
+
+const arrayNotContaining = sample => new ArrayContaining(sample, true);
+
+exports.arrayNotContaining = arrayNotContaining;
+
+const objectContaining = sample => new ObjectContaining(sample);
+
+exports.objectContaining = objectContaining;
+
+const objectNotContaining = sample => new ObjectContaining(sample, true);
+
+exports.objectNotContaining = objectNotContaining;
+
+const stringContaining = expected => new StringContaining(expected);
+
+exports.stringContaining = stringContaining;
+
+const stringNotContaining = expected => new StringContaining(expected, true);
+
+exports.stringNotContaining = stringNotContaining;
+
+const stringMatching = expected => new StringMatching(expected);
+
+exports.stringMatching = stringMatching;
+
+const stringNotMatching = expected => new StringMatching(expected, true);
+
+exports.stringNotMatching = stringNotMatching;
+
+const closeTo = (expected, precision) => new CloseTo(expected, precision);
+
+exports.closeTo = closeTo;
+
+const notCloseTo = (expected, precision) =>
+  new CloseTo(expected, precision, true);
+
+exports.notCloseTo = notCloseTo;

data/packages/webpacker/node_modules/expect/build/extractExpectedAssertionsErrors.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 { Expect } from './types';
+declare const extractExpectedAssertionsErrors: Expect['extractExpectedAssertionsErrors'];
+export default extractExpectedAssertionsErrors;

data/packages/webpacker/node_modules/expect/build/extractExpectedAssertionsErrors.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+var _jestMatchersObject = require('./jestMatchersObject');
+
+/**
+ * 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 resetAssertionsLocalState = () => {
+  (0, _jestMatchersObject.setState)({
+    assertionCalls: 0,
+    expectedAssertionsNumber: null,
+    isExpectingAssertions: false
+  });
+}; // Create and format all errors related to the mismatched number of `expect`
+// calls and reset the matcher's state.
+
+const extractExpectedAssertionsErrors = () => {
+  const result = [];
+  const {
+    assertionCalls,
+    expectedAssertionsNumber,
+    expectedAssertionsNumberError,
+    isExpectingAssertions,
+    isExpectingAssertionsError
+  } = (0, _jestMatchersObject.getState)();
+  resetAssertionsLocalState();
+
+  if (
+    typeof expectedAssertionsNumber === 'number' &&
+    assertionCalls !== expectedAssertionsNumber
+  ) {
+    const numOfAssertionsExpected = (0, _jestMatcherUtils.EXPECTED_COLOR)(
+      (0, _jestMatcherUtils.pluralize)('assertion', expectedAssertionsNumber)
+    );
+    expectedAssertionsNumberError.message =
+      (0, _jestMatcherUtils.matcherHint)(
+        '.assertions',
+        '',
+        String(expectedAssertionsNumber),
+        {
+          isDirectExpectCall: true
+        }
+      ) +
+      '\n\n' +
+      `Expected ${numOfAssertionsExpected} to be called but received ` +
+      (0, _jestMatcherUtils.RECEIVED_COLOR)(
+        (0, _jestMatcherUtils.pluralize)('assertion call', assertionCalls || 0)
+      ) +
+      '.';
+    result.push({
+      actual: assertionCalls.toString(),
+      error: expectedAssertionsNumberError,
+      expected: expectedAssertionsNumber.toString()
+    });
+  }
+
+  if (isExpectingAssertions && assertionCalls === 0) {
+    const expected = (0, _jestMatcherUtils.EXPECTED_COLOR)(
+      'at least one assertion'
+    );
+    const received = (0, _jestMatcherUtils.RECEIVED_COLOR)('received none');
+    isExpectingAssertionsError.message =
+      (0, _jestMatcherUtils.matcherHint)('.hasAssertions', '', '', {
+        isDirectExpectCall: true
+      }) +
+      '\n\n' +
+      `Expected ${expected} to be called but ${received}.`;
+    result.push({
+      actual: 'none',
+      error: isExpectingAssertionsError,
+      expected: 'at least one'
+    });
+  }
+
+  return result;
+};
+
+var _default = extractExpectedAssertionsErrors;
+exports.default = _default;

data/packages/webpacker/node_modules/expect/build/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 { Expect, MatcherState as JestMatcherState, Matchers as MatcherInterface } from './types';
+declare const expectExport: Expect<JestMatcherState>;
+declare namespace expectExport {
+    type MatcherState = JestMatcherState;
+    interface Matchers<R, T = unknown> extends MatcherInterface<R, T> {
+    }
+}
+export = expectExport;