@dereekb/util 10.0.4 → 10.0.6

package/src/lib/value/modifier.d.ts

@@ -1,5 +1,5 @@
-import { ArrayOrValue } from '../array';
-import { Maybe } from './maybe.type';
+import { type ArrayOrValue } from '../array';
+import { type Maybe } from './maybe.type';
 /**
  * Modifier key
  */

package/src/lib/value/point.d.ts

@@ -1,6 +1,6 @@
-import { Factory } from '../getter/getter';
-import { NumberPrecision, RoundToPrecisionFunctionType } from '../number/round';
-import { Maybe } from './maybe.type';
+import { type Factory } from '../getter/getter';
+import { type NumberPrecision, type RoundToPrecisionFunctionType } from '../number/round';
+import { type Maybe } from './maybe.type';
 /**
  * Latitude value
  */

package/src/lib/value/use.d.ts

@@ -1,7 +1,7 @@
-import { AsyncGetterOrValue, GetterOrValue } from '../getter';
-import { PromiseOrValue } from '../promise/promise.type';
-import { MapFunction } from './map';
-import { Maybe } from './maybe.type';
+import { type AsyncGetterOrValue, type GetterOrValue } from '../getter';
+import { type PromiseOrValue } from '../promise/promise.type';
+import { type MapFunction } from './map';
+import { type Maybe } from './maybe.type';
 /**
  * A map function with the intent of using the input value, and returning another value.
  */

package/src/lib/value/vector.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from './maybe.type';
+import { type Maybe } from './maybe.type';
 export interface Vector {
     x: number;
     y: number;

package/test/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/test/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/test/index.cjs.js

@@ -0,0 +1,555 @@
+'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

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