@dereekb/util 10.0.6 → 10.0.8

package/test/index.cjs.js

@@ -1,555 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var util = require('@dereekb/util');
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-/**
- * Abstract JestTestContextFixture instance.
- */
-class AbstractJestTestContextFixture {
-  get instance() {
-    return this._instance;
-  }
-  setInstance(instance) {
-    if (this._instance != null) {
-      throw new Error(`The testing fixture is locked. Don't call setInstance() directly.`);
-    }
-    this._instance = instance;
-    return () => {
-      delete this._instance;
-    };
-  }
-}
-/**
- * Abstract JestTestContextFixture instance with a parent.
- */
-class AbstractChildJestTestContextFixture extends AbstractJestTestContextFixture {
-  constructor(parent) {
-    super();
-    this.parent = parent;
-  }
-}
-/**
- * Creates a JestTestContextBuilderFunction given the input builder.
- *
- * @param builder
- * @returns
- */
-function jestTestContextBuilder(builder) {
-  return inputConfig => {
-    const config = builder.buildConfig(inputConfig);
-    return buildTests => {
-      const fixture = builder.buildFixture(config);
-      // add before each
-      if (builder.beforeEach != null) {
-        beforeEach(builder.beforeEach);
-      }
-      // add tests
-      useJestContextFixture({
-        fixture,
-        /**
-         * Build tests by passing the fixture to the testing functions.
-         *
-         * This will inject all tests and sub Jest lifecycle items.
-         */
-        buildTests,
-        initInstance: () => builder.setupInstance(config),
-        destroyInstance: instance => builder.teardownInstance(instance, config)
-      });
-      // add after each
-      if (builder.afterEach != null) {
-        afterEach(builder.afterEach);
-      }
-    };
-  };
-}
-/**
- * Creates a test context and jest configurations that will initialize an instance
- */
-function useJestContextFixture(config) {
-  const {
-    buildTests,
-    fixture,
-    initInstance,
-    destroyInstance
-  } = config;
-  let clearInstance;
-  let instance;
-  // Create an instance
-  beforeEach(() => __awaiter(this, void 0, void 0, function* () {
-    try {
-      instance = yield initInstance();
-      clearInstance = fixture.setInstance(instance);
-    } catch (e) {
-      console.error('Failed building a test instance due to an error in buildInstance(). Error: ', e);
-      if (clearInstance) {
-        clearInstance();
-      }
-      throw e;
-    }
-  }));
-  // Declare tests
-  buildTests(fixture);
-  // Cleanup
-  afterEach(() => __awaiter(this, void 0, void 0, function* () {
-    if (clearInstance) {
-      clearInstance();
-    }
-    if (fixture.instance != null) {
-      console.warn('Expected instance to be set on fixture for cleanup but was set to something else.');
-    }
-    if (destroyInstance) {
-      try {
-        yield destroyInstance(instance);
-        instance = undefined;
-      } catch (e) {
-        console.error('Failed due to error in destroyInstance()');
-        throw e;
-      }
-    }
-  }));
-}
-
-var makeError = {exports: {}};
-
-(function (module, exports) {
-
-// ===================================================================
-
-var construct = typeof Reflect !== "undefined" ? Reflect.construct : undefined;
-var defineProperty = Object.defineProperty;
-
-// -------------------------------------------------------------------
-
-var captureStackTrace = Error.captureStackTrace;
-if (captureStackTrace === undefined) {
-  captureStackTrace = function captureStackTrace(error) {
-    var container = new Error();
-
-    defineProperty(error, "stack", {
-      configurable: true,
-      get: function getStack() {
-        var stack = container.stack;
-
-        // Replace property with value for faster future accesses.
-        defineProperty(this, "stack", {
-          configurable: true,
-          value: stack,
-          writable: true,
-        });
-
-        return stack;
-      },
-      set: function setStack(stack) {
-        defineProperty(error, "stack", {
-          configurable: true,
-          value: stack,
-          writable: true,
-        });
-      },
-    });
-  };
-}
-
-// -------------------------------------------------------------------
-
-function BaseError(message) {
-  if (message !== undefined) {
-    defineProperty(this, "message", {
-      configurable: true,
-      value: message,
-      writable: true,
-    });
-  }
-
-  var cname = this.constructor.name;
-  if (cname !== undefined && cname !== this.name) {
-    defineProperty(this, "name", {
-      configurable: true,
-      value: cname,
-      writable: true,
-    });
-  }
-
-  captureStackTrace(this, this.constructor);
-}
-
-BaseError.prototype = Object.create(Error.prototype, {
-  // See: https://github.com/JsCommunity/make-error/issues/4
-  constructor: {
-    configurable: true,
-    value: BaseError,
-    writable: true,
-  },
-});
-
-// -------------------------------------------------------------------
-
-// Sets the name of a function if possible (depends of the JS engine).
-var setFunctionName = (function() {
-  function setFunctionName(fn, name) {
-    return defineProperty(fn, "name", {
-      configurable: true,
-      value: name,
-    });
-  }
-  try {
-    var f = function() {};
-    setFunctionName(f, "foo");
-    if (f.name === "foo") {
-      return setFunctionName;
-    }
-  } catch (_) {}
-})();
-
-// -------------------------------------------------------------------
-
-function makeError(constructor, super_) {
-  if (super_ == null || super_ === Error) {
-    super_ = BaseError;
-  } else if (typeof super_ !== "function") {
-    throw new TypeError("super_ should be a function");
-  }
-
-  var name;
-  if (typeof constructor === "string") {
-    name = constructor;
-    constructor =
-      construct !== undefined
-        ? function() {
-            return construct(super_, arguments, this.constructor);
-          }
-        : function() {
-            super_.apply(this, arguments);
-          };
-
-    // If the name can be set, do it once and for all.
-    if (setFunctionName !== undefined) {
-      setFunctionName(constructor, name);
-      name = undefined;
-    }
-  } else if (typeof constructor !== "function") {
-    throw new TypeError("constructor should be either a string or a function");
-  }
-
-  // Also register the super constructor also as `constructor.super_` just
-  // like Node's `util.inherits()`.
-  //
-  // eslint-disable-next-line dot-notation
-  constructor.super_ = constructor["super"] = super_;
-
-  var properties = {
-    constructor: {
-      configurable: true,
-      value: constructor,
-      writable: true,
-    },
-  };
-
-  // If the name could not be set on the constructor, set it on the
-  // prototype.
-  if (name !== undefined) {
-    properties.name = {
-      configurable: true,
-      value: name,
-      writable: true,
-    };
-  }
-  constructor.prototype = Object.create(super_.prototype, properties);
-
-  return constructor;
-}
-exports = module.exports = makeError;
-exports.BaseError = BaseError;
-}(makeError, makeError.exports));
-
-/**
- * https://github.com/facebook/jest/issues/11698
- *
- * Since fail() was silently removed, we redefine it.
- */
-/**
- * Passes the error to the JestDoneCallback.
- * @param done
- * @param e
- */
-function failWithJestDoneCallback(done, e = new Error('failed test')) {
-  if (done.fail != null) {
-    done.fail(e);
-  } else {
-    done(e);
-  }
-}
-// MARK: Errors
-/**
- * Error thrown by fail() and used by expectError()
- */
-class JestExpectedFailError extends makeError.exports.BaseError {}
-function failSuccessfullyError(message) {
-  return new JestExpectedFailError(message);
-}
-function failSuccessfully(message) {
-  throw failSuccessfullyError(message);
-}
-/**
- * Error thrown when success occurs when it should not have.
- */
-class JestUnexpectedSuccessFailureError extends makeError.exports.BaseError {}
-function failDueToSuccessError(message) {
-  return new JestUnexpectedSuccessFailureError(message !== null && message !== void 0 ? message : 'expected an error to occur but was successful instead');
-}
-function failTest(message) {
-  throw failDueToSuccessError(message);
-}
-function failDueToSuccess() {
-  throw failDueToSuccessError();
-}
-function failWithDoneDueToSuccess(done) {
-  failWithJestDoneCallback(done, failDueToSuccessError());
-}
-function EXPECT_ERROR_DEFAULT_HANDLER(e) {
-  if (e instanceof JestExpectedFailError) ; else {
-    throw e;
-  }
-}
-function expectFail(errorFn) {
-  function handleError(e) {
-    if (e instanceof JestUnexpectedSuccessFailureError) {
-      throw e;
-    } else {
-      failSuccessfully();
-    }
-  }
-  try {
-    const result = errorFn();
-    if (util.isPromise(result)) {
-      return result.then(failDueToSuccess).catch(handleError);
-    } else {
-      failDueToSuccess();
-    }
-  } catch (e) {
-    handleError(e);
-  }
-}
-function expectSuccessfulFail(errorFn, handleError = EXPECT_ERROR_DEFAULT_HANDLER) {
-  try {
-    const result = errorFn();
-    if (util.isPromise(result)) {
-      return result.then(failDueToSuccess).catch(handleError);
-    } else {
-      failDueToSuccess();
-    }
-  } catch (e) {
-    handleError(e);
-  }
-}
-/**
- * Used to wrap a Jest testing function and watch for JestExpectedFailError errors in order to pass the test. Other exceptions are treated normally as failures.
- *
- * This is typically used in conjunction with failSuccessfully(), expectSuccessfulFail(), or expectFail().
- *
- * @param fn
- * @param strict
- * @returns
- */
-function shouldFail(fn) {
-  const usesDoneCallback = fn.length > 0;
-  return done => {
-    function handleError(e) {
-      if (!(e instanceof JestExpectedFailError)) {
-        failWithJestDoneCallback(done, e);
-      } else {
-        done();
-      }
-    }
-    expectSuccessfulFail(() => {
-      let result;
-      if (usesDoneCallback) {
-        const fakeDone = util.build({
-          base: fakeDoneHandler(),
-          build: x => {
-            x.failSuccessfully = () => {
-              fakeDone(failSuccessfullyError());
-            };
-          }
-        });
-        const callbackWithDoneResult = fn(fakeDone);
-        if (util.isPromise(callbackWithDoneResult)) {
-          fakeDone.reject(new Error('Configured to use "done" value while returning a promise. Configure your test to use one or the other.'));
-        }
-        // return the fake done promise. Done/fail will resolve as a promise.
-        result = fakeDone._ref.promise;
-      } else {
-        result = fn();
-      }
-      return result;
-    }, handleError);
-  };
-}
-function itShouldFail(describeOrFn, fn) {
-  let description;
-  if (typeof describeOrFn === 'string') {
-    description = `should fail ${describeOrFn}`;
-  } else {
-    fn = describeOrFn;
-    description = 'should fail';
-  }
-  it(description, shouldFail(fn));
-}
-function fakeDoneHandler() {
-  const promiseRef = util.promiseReference();
-  const doneHandler = promiseRef.resolve;
-  const failHandler = e => {
-    promiseRef.reject(e);
-  };
-  const fakeDone = error => {
-    if (error) {
-      failHandler(error);
-    } else {
-      doneHandler(0);
-    }
-  };
-  fakeDone.fail = error => {
-    failHandler(error);
-  };
-  fakeDone._ref = promiseRef;
-  fakeDone.promise = promiseRef.promise;
-  fakeDone.resolve = promiseRef.resolve;
-  fakeDone.reject = promiseRef.reject;
-  return fakeDone;
-}
-
-class AbstractWrappedFixture {
-  constructor(fixture) {
-    this.fixture = fixture;
-  }
-}
-class AbstractWrappedFixtureWithInstance extends AbstractJestTestContextFixture {
-  constructor(parent) {
-    super();
-    this.parent = parent;
-  }
-}
-/**
- * Wraps the input JestTestContextFactory to emit another type of Fixture for tests.
- *
- * @returns
- */
-function wrapJestTestContextFactory(config) {
-  return factory => {
-    return buildTests => {
-      factory(inputFixture => {
-        const wrap = config.wrapFixture(inputFixture);
-        let effect;
-        // add before each
-        if (config.setupWrap != null) {
-          beforeEach(() => __awaiter(this, void 0, void 0, function* () {
-            effect = yield config.setupWrap(wrap);
-          }));
-        }
-        // add tests
-        buildTests(wrap);
-        // add after each
-        if (config.teardownWrap != null) {
-          afterEach(() => __awaiter(this, void 0, void 0, function* () {
-            yield config.teardownWrap(wrap, effect);
-          }));
-        }
-      });
-    };
-  };
-}
-function instanceWrapJestTestContextFactory(config) {
-  return wrapJestTestContextFactory({
-    wrapFixture: config.wrapFixture,
-    setupWrap: wrap => __awaiter(this, void 0, void 0, function* () {
-      const instance = yield config.makeInstance(wrap);
-      const effect = wrap.setInstance(instance);
-      if (config.setupInstance) {
-        yield config.setupInstance(instance, wrap);
-      }
-      return effect;
-    }),
-    teardownWrap: (wrap, deleteInstanceEffect) => __awaiter(this, void 0, void 0, function* () {
-      deleteInstanceEffect === null || deleteInstanceEffect === void 0 ? void 0 : deleteInstanceEffect();
-      if (config.teardownInstance) {
-        yield config.teardownInstance(wrap.instance);
-      }
-    })
-  });
-}
-
-/**
- * Creates a test context and jest configurations that provides a function to build tests based on the configuration.
- */
-function useJestFunctionFixture(config, buildTests) {
-  const {
-    fn
-  } = config;
-  const forward = util.forwardFunction(fn);
-  buildTests(forward);
-}
-/**
- * Creates a test context and jest configurations that provides a function to build tests based on the configuration.
- */
-function useJestFunctionMapFixture(config, buildTests) {
-  const forwardedFunctions = util.mapObjectMap(config.fns, fn => util.forwardFunction(fn));
-  buildTests(forwardedFunctions);
-}
-
-exports.AbstractChildJestTestContextFixture = AbstractChildJestTestContextFixture;
-exports.AbstractJestTestContextFixture = AbstractJestTestContextFixture;
-exports.AbstractWrappedFixture = AbstractWrappedFixture;
-exports.AbstractWrappedFixtureWithInstance = AbstractWrappedFixtureWithInstance;
-exports.EXPECT_ERROR_DEFAULT_HANDLER = EXPECT_ERROR_DEFAULT_HANDLER;
-exports.JestExpectedFailError = JestExpectedFailError;
-exports.JestUnexpectedSuccessFailureError = JestUnexpectedSuccessFailureError;
-exports.expectFail = expectFail;
-exports.expectSuccessfulFail = expectSuccessfulFail;
-exports.failDueToSuccess = failDueToSuccess;
-exports.failDueToSuccessError = failDueToSuccessError;
-exports.failSuccessfully = failSuccessfully;
-exports.failSuccessfullyError = failSuccessfullyError;
-exports.failTest = failTest;
-exports.failWithDoneDueToSuccess = failWithDoneDueToSuccess;
-exports.failWithJestDoneCallback = failWithJestDoneCallback;
-exports.fakeDoneHandler = fakeDoneHandler;
-exports.instanceWrapJestTestContextFactory = instanceWrapJestTestContextFactory;
-exports.itShouldFail = itShouldFail;
-exports.jestTestContextBuilder = jestTestContextBuilder;
-exports.shouldFail = shouldFail;
-exports.useJestContextFixture = useJestContextFixture;
-exports.useJestFunctionFixture = useJestFunctionFixture;
-exports.useJestFunctionMapFixture = useJestFunctionMapFixture;
-exports.wrapJestTestContextFactory = wrapJestTestContextFactory;

package/test/index.cjs.mjs

@@ -1,2 +0,0 @@
-export * from './index.cjs.js';
-export { _default as default } from './index.cjs.default.js';