Use yoctodelay instead.

Breaking something? What's the original and fixed?

 mergeWith(...rest, (destValue, srcValue, key, dest, src, stack) => {
    if (!isArray(destValue) && !isArray(srcValue)) return

    if (isArray(destValue)) {
     // srcValue may be primitive value
      _destValue = destValue.concat(srcValue)
    } else if (isArray(srcValue)) {
      _destValue = [...srcValue]
    }

    return _destValue
  })

Or possibly return an empty React.Fragment. I do that instead of using null.

return isLoading
    ? <></> 
    : (
            /* ... */
       )

<!-- 🍩 Please don't ignore this template -->

<!-- 1️⃣ Explain here why this rule would be beneficial --> Accessing a property inside an accessor with the same name will cause infinite recursion.

Fail

<!-- 2️⃣ Specify an example of code that should be detected -->

get foo() {
    return this.foo;
}

set foo(v) {
    this.foo = v;
}

Pass

<!-- 3️⃣ Specify an example of code that would be accepted in its place -->

get foo() {
    return this._foo;
}

set foo(v) {
    this._foo = v;
}

get bar() {
    return that.bar;
}

set bar(v) {
    that.bar = v;
}

<!-- 🍩 Please don't ignore this template -->

<!-- 1️⃣ Explain here why this rule would be beneficial --> A switch statement is easier to read than multiple if statements with simple equality comparisons.

Fail

<!-- 2️⃣ Specify an example of code that should be detected -->

if (foo === bar) {
    /* ... */
}
else if (foo === baz) {
    /* ... */
}
else if (foo === arglebargl) {
    /* ... */
}
else if (foo === glopglyph) {
    /* ... */
}

Pass

<!-- 3️⃣ Specify an example of code that would be accepted in its place -->

if (foo === bar) {
    /* ... */
}
else if (foo === baz) {
    /* ... */
}

switch (foo) {
    case bar:
        /* ... */
        break;
    case baz:
        /* ... */
        break;
    case arglebargl:
        /* ... */
        break;
    case glopglyph:
        /* ... */
        break;
}

This could have a minimumCases option, defaulting to 3.

<!-- 🍩 Please don't ignore this template -->

<!-- 1️⃣ Explain here why this rule would be beneficial --> The this keyword on static methods refers the class instance (the constructor). This can be confusing.

Fail

<!-- 2️⃣ Specify an example of code that should be detected -->

class A {
    static foo() {
        doSomething()
    }

    static bar() {
        this.foo()   //ERROR: Unexpected 'this'.
    }
}

class B extends A {
    static foo() {
        super.foo()  //ERROR: Unexpected 'super'.
    }
}

Pass

<!-- 3️⃣ Specify an example of code that would be accepted in its place -->

class A {
    static foo() {
        doSomething()
    }

    static bar() {
        A.foo()
    }
}

class B extends A {
    static foo() {
        A.foo()
    }
}

HI,

I just upgraded to 7.0.0, but I get the following error when loading the store using a JSON scheme:

Error: unknown format "date-time" ignored in schema at path "#/properties/extra/properties/lastStartDate"

Nothing else has changed, just the packages upgrade. AM i missing something?

My JSON Scheme is the following:

  const AppDatabaseSchema: Schema<AppDatabaseModel> = {
    extra: {
      type: 'object',
      properties: {
        lastStartDate: {
          type: "string",
          format: "date-time"
        }
      }
    }
  }

And I initialize it like this:

  this.store = new Store<AppDatabaseModel>({
        name: "appDatabase",
        schema: AppDatabaseSchema,
        clearInvalidConfig: true
   });

Thank you

fg
	}), 'bar=&foo=,a,,');
	fdfgfdg

Can you add a test like this where the skipnull and skipemptystring options are set?

one test where both are involved, sure.

You also need to add some more tests to ensure the parse function can correctly handle this.

This fixes stringify(), are you trying to say me to fix its counter-part in parse()?

Right, what I meant was the name of the schema variable, not the option name.

I just used schema and Schema in the initial issue to say that even a slight change in the schema variable name causes string defaults to be returned as undefined. (Notice: one has a lowercase s, and the other has an uppercase S)

So, this works:

const schema = {...some_schema_object}

const config = new Conf({schema})  // works as expected

But, the following examples don't work:

const someRandomVariableName = {...some_schema_object}

const config = new Conf({someRandomVariableName})  // does not work

or

const confSchema = {...some_schema_object}

const config = new Conf({confSchema})  // does not work

or

const Schema = {...some_schema_object}

const config = new Conf({Schema})  // does not work

What about the option to call ow without a type?

ow(5, ow.is(x => greaterThan(10, x)));
// => ArgumentError: Expected `5` to be greater than `10`

ow(5, 'custom label', ow.is(x => greaterThan(10, x)));
// => ArgumentError: (custom label) Expected `5` to be greater than `10`

I had to disable (1091fdaaff82de2b9eac0f674a0dafc719a7bff7) some problematic rules in the default config until we manage to fix some issues with them:

custom-error-definition

• [x] #150
• [x] #90
• [ ] checking other problems(fisker)

no-fn-reference-in-iterator

• [x] #121
• [x] enable in #666

no-unsafe-regex

• [ ] #153

Closing in favor of https://github.com/sindresorhus/eslint-plugin-unicorn/pull/680.

This is now accepted.

This is now accepted.

But it's blocked by:

Does ESLint support this feature yet?

Any suggestions on how to best resolve this?

22d22b8

Why only when after is true?

It would also be useful to include a use-case for this option (like you mention in the PR description).

Also, make it clear that "time" is in milliseconds.

		Only applies when the `after` option is `true`.

test('`maxWait` option', async t => {

It needs a clearer description of how it's different from wait.

You also need to update the readme.