Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

⬆️ Update dependency effect to v3 #126

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

⬆️ Update dependency effect to v3 #126

wants to merge 1 commit into from

Conversation

renovate[bot]
Copy link
Contributor

@renovate renovate bot commented Apr 16, 2024 •
edited
Loading

This PR contains the following updates:

Package Change Age Adoption Passing Confidence
effect (source) 2.2.5 -> 3.10.13 age adoption passing confidence

Release Notes

Effect-TS/effect (effect)

v3.10.13

Compare Source

Patch Changes

v3.10.12

Compare Source

Patch Changes

v3.10.11

Compare Source

Patch Changes

v3.10.10

Compare Source

Patch Changes

  • #​3893 cd720ae Thanks @​tim-smart! - support "dropping" & "sliding" strategies in Mailbox

  • #​3893 cd720ae Thanks @​tim-smart! - add Mailbox.fromStream api

  • #​3886 b631f40 Thanks @​fubhy! - Optimized Base64.decode by not capturing the padding characters in the underlying array buffer.

    Previously, the implementation first captured the padding characters in the underlying array buffer and
    then returned a new subarray view of the buffer with the padding characters removed.

    By not capturing the padding characters, we avoid the creation of another typed array instance for the
    subarray view.

v3.10.9

Compare Source

Patch Changes

v3.10.8

Compare Source

Patch Changes

v3.10.7

Compare Source

Patch Changes

v3.10.6

Compare Source

Patch Changes

v3.10.5

Compare Source

Patch Changes

v3.10.4

Compare Source

Patch Changes

  • #​3842 2367708 Thanks @​gcanti! - add support for Schema.OptionFromUndefinedOr in JSON Schema generation, closes #​3839

    Before

    import { JSONSchema, Schema } from "effect"

const schema = Schema.Struct({
  a: Schema.OptionFromUndefinedOr(Schema.Number)
})

console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
/*
throws:
Error: Missing annotation
at path: ["a"]
details: Generating a JSON Schema for this schema requires a "jsonSchema" annotation
schema (UndefinedKeyword): undefined
*/

    After

    import { JSONSchema, Schema } from "effect"

const schema = Schema.Struct({
  a: Schema.OptionFromUndefinedOr(Schema.Number)
})

console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
/*
Output:
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": [],
  "properties": {
    "a": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
*/

v3.10.3

Compare Source

Patch Changes

v3.10.2

Compare Source

Patch Changes

v3.10.1

Compare Source

Patch Changes

v3.10.0

Compare Source

Minor Changes
Modules

Before

import {
  Arbitrary,
  AST,
  FastCheck,
  JSONSchema,
  ParseResult,
  Pretty,
  Schema
} from "@​effect/schema"

After

import {
  Arbitrary,
  SchemaAST, // changed
  FastCheck,
  JSONSchema,
  ParseResult,
  Pretty,
  Schema
} from "effect"
Formatters

ArrayFormatter / TreeFormatter merged into ParseResult module.

Before

import { ArrayFormatter, TreeFormatter } from "@​effect/schema"

After

import { ArrayFormatter, TreeFormatter } from "effect/ParseResult"
Serializable

Merged into Schema module.

Equivalence

Merged into Schema module.

Before

import { Equivalence } from "@​effect/schema"

Equivalence.make(myschema)

After

import { Schema } from "@​effect/schema"

Schema.equivalence(myschema)

v3.9.2

Compare Source

Patch Changes

v3.9.1

Compare Source

Patch Changes

v3.9.0

Compare Source

Minor Changes

  • #​3620 ff3d1aa Thanks @​vinassefranche! - Adds HashMap.HashMap.Entry type helper

  • #​3620 0ba66f2 Thanks @​tim-smart! - add deno support to Inspectable

  • #​3620 bf77f51 Thanks @​KhraksMamtsov! - Latch implements Effect<void> with .await semantic

  • #​3620 0779681 Thanks @​KhraksMamtsov! - Effect.mapAccum & Array.mapAccum preserve non-emptiness

  • #​3620 534129f Thanks @​KhraksMamtsov! - Pool is now a subtype of Effect, equivalent to Pool.get

  • #​3620 d75140c Thanks @​mikearnaldi! - Support providing an array of layers via Effect.provide and Layer.provide

  • #​3620 be0451c Thanks @​leonitousconforti! - support ManagedRuntime in Effect.provide

  • #​3620 be0451c Thanks @​leonitousconforti! - ManagedRuntime<R, E> is subtype of Effect<Runtime<R>, E, never>

  • #​3620 5b36494 Thanks @​KhraksMamtsov! - Tuple.map transforms each element of tuple using the given function, treating tuple homomorphically

    import { pipe, Tuple } from "effect"

const result = pipe(
  //  ^? [string, string, string]
  ["a", 1, false] as const,
  T.map((el) => {
    //^? "a" | 1 | false
    return el.toString().toUppercase()
  })
)
assert.deepStrictEqual(result, ["A", "1", "FALSE"])

  • #​3620 c716adb Thanks @​AlexGeb! - Add Array.pad function

  • #​3620 4986391 Thanks @​ianbollinger! - Add an isRegExp type guard

  • #​3620 d75140c Thanks @​mikearnaldi! - Implement Effect.Service as a Tag and Layer with Opaque Type.

    Namely the following is now possible:

    class Prefix extends Effect.Service<Prefix>()("Prefix", {
  sync: () => ({
    prefix: "PRE"
  })
}) {}

class Postfix extends Effect.Service<Postfix>()("Postfix", {
  sync: () => ({
    postfix: "POST"
  })
}) {}

const messages: Array<string> = []

class Logger extends Effect.Service<Logger>()("Logger", {
  accessors: true,
  effect: Effect.gen(function* () {
    const { prefix } = yield* Prefix
    const { postfix } = yield* Postfix
    return {
      info: (message: string) =>
        Effect.sync(() => {
          messages.push(`[${prefix}][${message}][${postfix}]`)
        })
    }
  }),
  dependencies: [Prefix.Default, Postfix.Default]
}) {}

describe("Effect", () => {
  it.effect("Service correctly wires dependencies", () =>
    Effect.gen(function* () {
      const { _tag } = yield* Logger
      expect(_tag).toEqual("Logger")
      yield* Logger.info("Ok")
      expect(messages).toEqual(["[PRE][Ok][POST]"])
      const { prefix } = yield* Prefix
      expect(prefix).toEqual("PRE")
      const { postfix } = yield* Postfix
      expect(postfix).toEqual("POST")
    }).pipe(Effect.provide([Logger.Default, Prefix.Default, Postfix.Default]))
  )
})

  • #​3620 d1387ae Thanks @​KhraksMamtsov! - Resource<A, E> is subtype of Effect<A, E>.
    ScopedRed<A> is subtype of Effect<A>.

Patch Changes

v3.8.5

Compare Source

Patch Changes

  • #​3734 88e85db Thanks @​mikearnaldi! - Ensure random numbers are correctly distributed

  • #​3717 83887ca Thanks @​mikearnaldi! - Consider async operation in runSync as a defect, add span based stack

  • #​3731 5266b6c Thanks @​patroza! - Improve DX of type errors from inside pipe and flow

  • #​3699 cdead5c Thanks @​jessekelly881! - added Stream.mergeWithTag

    Combines a struct of streams into a single stream of tagged values where the tag is the key of the struct.

    import { Stream } from "effect"

// Stream.Stream<{ _tag: "a"; value: number; } | { _tag: "b"; value: string; }>
const stream = Stream.mergeWithTag(
  {
    a: Stream.make(0),
    b: Stream.make("")
  },
  { concurrency: 1 }
)

  • #​3706 766a8af Thanks @​fubhy! - Made BigDecimal.scale dual.

v3.8.4

Compare Source

Patch Changes

v3.8.3

Compare Source

Patch Changes

v3.8.2

Compare Source

Patch Changes

v3.8.1

Compare Source

Patch Changes

v3.8.0

Compare Source

Minor Changes

  • #​3541 fcfa6ee Thanks @​Schniz! - add Logger.withLeveledConsole

    In browsers and different platforms, console.error renders differently than console.info. This helps to distinguish between different levels of logging. Logger.withLeveledConsole takes any logger and calls the respective Console method based on the log level. For instance, Effect.logError will call Console.error and Effect.logInfo will call Console.info.

    To use it, you can replace the default logger with a Logger.withLeveledConsole logger:

    import { Logger, Effect } from "effect"

const loggerLayer = Logger.withLeveledConsole(Logger.stringLogger)

Effect.gen(function* () {
  yield* Effect.logError("an error")
  yield* Effect.logInfo("an info")
}).pipe(Effect.provide(loggerLayer))

  • #​3541 bb9931b Thanks @​KhraksMamtsov! - Made Ref, SynchronizedRed and SubscriptionRef a subtype of Effect

  • #​3541 5798f76 Thanks @​tim-smart! - add Semaphore.withPermitsIfAvailable

    You can now use Semaphore.withPermitsIfAvailable to run an Effect only if the
    Semaphore has enough permits available. This is useful when you want to run an
    Effect only if you can acquire a permit without blocking.

    It will return an Option.Some with the result of the Effect if the permits were
    available, or None if they were not.

    import { Effect } from "effect"

Effect.gen(function* () {
  const semaphore = yield* Effect.makeSemaphore(1)
  semaphore.withPermitsIfAvailable(1)(Effect.void)
})

  • #​3541 5f0bfa1 Thanks @​KhraksMamtsov! - The Deferred<A> is now a subtype of Effect<A>. This change simplifies handling of deferred values, removing the need for explicit call Deffer.await.

    import { Effect, Deferred } from "effect"

Effect.gen(function* () {
  const deferred = yield* Deferred.make<string>()

  const before = yield* Deferred.await(deferred)
  const after = yield* deferred
})

  • #​3541 812a4e8 Thanks @​tim-smart! - add Logger.prettyLoggerDefault, to prevent duplicate pretty loggers

  • #​3541 273565e Thanks @​tim-smart! - add Effect.makeLatch, for creating a simple async latch

    import { Effect } from "effect"

Effect.gen(function* () {
  // Create a latch, starting in the closed state
  const latch = yield* Effect.makeLatch(false)

  // Fork a fiber that logs "open sesame" when the latch is opened
  const fiber = yield* Effect.log("open sesame").pipe(
    latch.whenOpen,
    Effect.fork
  )

  // Open the latch
  yield* latch.open
  yield* fiber.await
})

  • #​3541 569a801 Thanks @​KhraksMamtsov! - Dequeue<A> and Queue<A> is subtype of Effect<A>. This means that now it can be used as an Effect, and when called, it will automatically extract and return an item from the queue, without having to explicitly use the Queue.take function.

    Effect.gen(function* () {
  const queue = yield* Queue.unbounded<number>()
  yield* Queue.offer(queue, 1)
  yield* Queue.offer(queue, 2)
  const oldWay = yield* Queue.take(queue)
  const newWay = yield* queue
})

  • #​3541 aa1fa53 Thanks @​vinassefranche! - Add Number.round

  • #​3541 02f6b06 Thanks @​fubhy! - Add additional Duration conversion apis

    • Duration.toMinutes
    • Duration.toHours
    • Duration.toDays
    • Duration.toWeeks

  • #​3541 12b893e Thanks @​KhraksMamtsov! - The Fiber<A, E> is now a subtype of Effect<A, E>. This change removes the need for explicit call Fiber.join.

    import { Effect, Fiber } from "effect"

Effect.gen(function*() {
  const fiber = yield* Effect.fork(Effect.succeed(1))

  const oldWay = yield* Fiber.join(fiber)
  const now = yield* fiber
}))

  • #​3541 bbad27e Thanks @​dilame! - add Stream.share api

    The Stream.share api is a ref counted variant of the broadcast apis.

    It allows you to share a stream between multiple consumers, and will close the
    upstream when the last consumer ends.

  • #​3541 adf7d7a Thanks @​tim-smart! - add Mailbox module, a queue which can have done or failure signals

    import { Chunk, Effect, Mailbox } from "effect"
import * as assert from "node:assert"

Effect.gen(function* () {
  const mailbox = yield* Mailbox.make<number, string>()

  // add messages to the mailbox
  yield* mailbox.offer(1)
  yield* mailbox.offer(2)
  yield* mailbox.offerAll([3, 4, 5])

  // take messages from the mailbox
  const [messages, done] = yield* mailbox.takeAll
  assert.deepStrictEqual(Chunk.toReadonlyArray(messages), [1, 2, 3, 4, 5])
  assert.strictEqual(done, false)

  // signal that the mailbox is done
  yield* mailbox.end
  const [messages2, done2] = yield* mailbox.takeAll
  assert.deepStrictEqual(messages2, Chunk.empty())
  assert.strictEqual(done2, true)

  // signal that the mailbox is failed
  yield* mailbox.fail("boom")
})

  • #​3541 007289a Thanks @​mikearnaldi! - Cache some fiber references in the runtime to optimize reading in hot-paths

  • #​3541 42a8f99 Thanks @​fubhy! - Added RcMap.keys and MutableHashMap.keys.

    These functions allow you to get a list of keys currently stored in the underlying hash map.

    const map = MutableHashMap.make([
  ["a", "a"],
  ["b", "b"],
  ["c", "c"]
])
const keys = MutableHashMap.keys(map) // ["a", "b", "c"]
    Effect.gen(function* () {
  const map = yield* RcMap.make({
    lookup: (key) => Effect.succeed(key)
  })

  yield* RcMap.get(map, "a")
  yield* RcMap.get(map, "b")
  yield* RcMap.get(map, "c")

  const keys = yield* RcMap.keys(map) // ["a", "b", "c"]
})

  • #​3541 eebfd29 Thanks @​fubhy! - Add Duration.parts api

    const parts = Duration.parts(Duration.sum("5 minutes", "20 seconds"))
assert.equal(parts.minutes, 5)
assert.equal(parts.seconds, 20)

  • #​3541 040703d Thanks @​KhraksMamtsov! - The FiberRef<A> is now a subtype of Effect<A>. This change simplifies handling of deferred values, removing the need for explicit call FiberRef.get.

    import { Effect, FiberRef } from "effect"

Effect.gen(function* () {
  const fiberRef = yield* FiberRef.make("value")

  const before = yield* FiberRef.get(fiberRef)
  const after = yield* fiberRef
})

v3.7.3

Compare Source

Patch Changes

v3.7.2

Compare Source

Patch Changes

v3.7.1

Compare Source

Patch Changes

v3.7.0

Compare Source

Minor Changes

  • #​3410 2f456cc Thanks @​vinassefranche! - preserve Array.modify Array.modifyOption non emptiness

  • #​3410 8745e41 Thanks @​patroza! - improve: type Fiber.awaitAll as Exit<A, E>[].

  • #​3410 e557838 Thanks @​titouancreach! - New constructor Config.nonEmptyString

  • #​3410 d6e7e40 Thanks @​KhraksMamtsov! - preserve Array.replace Array.replaceOption non emptiness

  • #​3410 8356321 Thanks @​KhraksMamtsov! - add Effect.bindAll api

    This api allows you to combine Effect.all with Effect.bind. It is useful
    when you want to concurrently run multiple effects and then combine their
    results in a Do notation pipeline.

    import { Effect } from "effect"

const result = Effect.Do.pipe(
  Effect.bind("x", () => Effect.succeed(2)),
  Effect.bindAll(
    ({ x }) => ({
      a: Effect.succeed(x + 1),
      b: Effect.succeed("foo")
    }),
    { concurrency: 2 }
  )
)
assert.deepStrictEqual(Effect.runSync(result), {
  x: 2,
  a: 3,
  b: "foo"
})

  • #​3410 192f2eb Thanks @​tim-smart! - add propagateInterruption option to Fiber{Handle,Set,Map}

    This option will send any external interrupts to the .join result.

  • #​3410 718cb70 Thanks @​dilame! - feat(Stream): implement race operator, which accepts two upstreams and returns a stream that mirrors the first upstream to emit an item and interrupts the other upstream.

    import { Stream, Schedule, Console, Effect } from "effect"

const stream = Stream.fromSchedule(Schedule.spaced("2 millis")).pipe(
  Stream.race(Stream.fromSchedule(Schedule.spaced("1 millis"))),
  Stream.take(6),
  Stream.tap((n) => Console.log(n))
)

Effect.runPromise(Stream.runDrain(stream))
// Output each millisecond from the first stream, the rest streams are interrupted
// 0
// 1
// 2
// 3
// 4
// 5

  • #​3410 e9d0310 Thanks @​mikearnaldi! - Avoid automatic propagation of finalizer concurrency, closes #​3440

  • #​3410 6bf28f7 Thanks @​tim-smart! - add Context.getOrElse api, for gettings a Tag's value with a fallback

Patch Changes

v3.6.8

Compare Source

Patch Changes

v3.6.7

Compare Source

Patch Changes

v3.6.6

Compare Source

Patch Changes

v3.6.5

Compare Source

Patch Changes

v3.6.4

Compare Source

Patch Changes

v3.6.3

Compare Source

Patch Changes

v3.6.2

Compare Source

Patch Changes

v3.6.1

Compare Source

Patch Changes

v3.6.0

Compare Source

Minor Changes

  • #​3380 1e0fe80 Thanks @​tim-smart! - make List.Cons extend NonEmptyIterable

  • #​3380 8135294 Thanks @​tim-smart! - add DateTime module

    The DateTime module provides functionality for working with time, including
    support for time zones and daylight saving time.

    It has two main data types: DateTime.Utc and DateTime.Zoned.

    A DateTime.Utc represents a time in Coordinated Universal Time (UTC), and
    a DateTime.Zoned contains both a UTC timestamp and a time zone.

    There is also a CurrentTimeZone service, for setting a time zone contextually.

    import { DateTime, Effect } from "effect";

Effect.gen(function* () {
  // Get the current time in the current time zone
  const now = yield* DateTime.nowInCurrentZone;

  // Math functions are included
  const tomorrow = DateTime.add(now, 1, "day");

  // Convert to a different time zone
  // The UTC portion of the `DateTime` is preserved and only the time zone is
  // changed
  const sydneyTime = tomorrow.pipe(
    DateTime.unsafeSetZoneNamed("Australia/Sydney"),
  );
}).pipe(DateTime.withCurrentZoneNamed("America/New_York"));

  • #​3380 cd255a4 Thanks @​tim-smart! - add Stream.asyncPush api

    This api creates a stream from an external push-based resource.

    You can use the emit helper to emit values to the stream. You can also use
    the emit helper to signal the end of the stream by using apis such as
    emit.end or emit.fail.

    By default it uses an "unbounded" buffer size.
    You can customize the buffer size and strategy by passing an object as the
    second argument with the bufferSize and strategy fields.

    import { Effect, Stream } from "effect";

Stream.asyncPush<string>(
  (emit) =>
    Effect.acquireRelease(
      Effect.gen(function* () {
        yield* Effect.log("subscribing");
        return setInterval(() => emit.single("tick"), 1000);
      }),
      (handle) =>
        Effect.gen(function* () {
          yield* Effect.log("unsubscribing");
          clearInterval(handle);
        }),
    ),
  { bufferSize: 16, strategy: "dropping" },
);

  • #​3380 3845646 Thanks @​mikearnaldi! - Implement Struct.keys as a typed alternative to Object.keys

    import { Struct } from "effect";

const symbol: unique symbol = Symbol();

const value = {
  a: 1,
  b: 2,
  [symbol]: 3,
};

const keys: Array<"a" | "b"> = Struct.keys(value);

  • #​3380 2d09078 Thanks @​sukovanej! - Add Random.choice.

    import { Random } from "effect";

Effect.gen(function* () {
  const randomItem = yield* Random.choice([1, 2, 3]);
  console.log(randomItem);
});

  • #​3380 4bce5a0 Thanks @​vinassefranche! - Add onlyEffect option to Effect.tap

  • #​3380 4ddbff0 Thanks @​KhraksMamtsov! - Support Refinement in Predicate.tuple and Predicate.struct

  • #​3380 e74cc38 Thanks @​dilame! - Implement Stream.onEnd that adds an effect to be executed at the end of the stream.

    import { Console, Effect, Stream } from "effect";

const stream = Stream.make(1, 2, 3).pipe(
  Stream.map((n) => n * 2),
  Stream.tap((n) => Console.log(`after mapping: ${n}`)),
  Stream.onEnd(Console.log("Stream ended")),
);

Effect.runPromise(Stream.runCollect(stream)).then(console.log);
// after mapping: 2
// after mapping: 4
// after mapping: 6
// Stream ended
// { _id: 'Chunk', values: [ 2, 4, 6 ] }

  • #​3380 bb069b4 Thanks @​dilame! - Implement Stream.onStart that adds an effect to be executed at the start of the stream.

    import { Console, Effect, Stream } from "effect";

const stream = Stream.make(1, 2, 3).pipe(
  Stream.onStart(Console.log("Stream started")),
  Stream.map((n) => n * 2),
  Stream.tap((n) => Console.log(`after mapping: ${n}`)),
);

Effect.runPromise(Stream.runCollect(stream)).then(console.log);
// Stream started
// after mapping: 2
// after mapping: 4
// after mapping: 6
// { _id: 'Chunk', values: [ 2, 4, 6 ] }

  • #​3380 cd255a4 Thanks @​tim-smart! - add bufferSize option to Stream.fromEventListener

  • #​3380 7d02174 Thanks @​fubhy! - Changed various function signatures to return Array instead of ReadonlyArray

v3.5.9

Compare Source

Patch Changes

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@renovate renovate bot added renovate upgrade Any kind of dependency updates labels Apr 16, 2024
@renovate Renovate
Copy link
Contributor Author

renovate bot commented Apr 16, 2024 •
edited
Loading

⚠ Artifact update problem

Renovate failed to update an artifact related to this branch. You probably do not want to merge this PR as-is.

♻ Renovate will retry this branch, including artifacts, only when one of the following happens:

  • any of the package files in this branch needs updating, or
  • the branch becomes conflicted, or
  • you click the rebase/retry checkbox if found above, or
  • you rename this PR's title to start with "rebase!" to trigger it manually

The artifact failure details are included below:

File name: package-lock.json
npm error code ERESOLVE
npm error ERESOLVE could not resolve
npm error
npm error While resolving: @effect/[email protected]
npm error Found: [email protected]
npm error node_modules/effect
npm error   effect@"3.1.3" from the root project
npm error
npm error Could not resolve dependency:
npm error peer effect@"^2.1.1" from @effect/[email protected]
npm error node_modules/@effect/schema
npm error   @effect/schema@"0.60.4" from the root project
npm error
npm error Conflicting peer dependency: [email protected]
npm error node_modules/effect
npm error   peer effect@"^2.1.1" from @effect/[email protected]
npm error   node_modules/@effect/schema
npm error     @effect/schema@"0.60.4" from the root project
npm error
npm error Fix the upstream dependency conflict, or retry
npm error this command with --force or --legacy-peer-deps
npm error to accept an incorrect (and potentially broken) dependency resolution.
npm error
npm error
npm error For a full report see:
npm error /tmp/renovate/cache/others/npm/_logs/2024-05-08T22_22_18_081Z-eresolve-report.txt

npm error A complete log of this run can be found in: /tmp/renovate/cache/others/npm/_logs/2024-05-08T22_22_18_081Z-debug-0.log

@renovate renovate bot force-pushed the renovate/effect-3.x branch 8 times, most recently from ac64789 to 5c44085 Compare April 25, 2024 04:19
@renovate renovate bot force-pushed the renovate/effect-3.x branch 10 times, most recently from 9d2cf0f to d4fa257 Compare May 2, 2024 22:37
@renovate renovate bot force-pushed the renovate/effect-3.x branch 9 times, most recently from b3879b8 to a7c2703 Compare May 8, 2024 22:22
@renovate renovate bot force-pushed the renovate/effect-3.x branch 3 times, most recently from ab246f4 to 59569d4 Compare October 13, 2024 21:34
@renovate renovate bot force-pushed the renovate/effect-3.x branch 5 times, most recently from 809f690 to d571a74 Compare October 25, 2024 15:28
@renovate renovate bot force-pushed the renovate/effect-3.x branch 17 times, most recently from 58b304b to e142aca Compare November 4, 2024 03:23
@renovate renovate bot force-pushed the renovate/effect-3.x branch 3 times, most recently from 65c2934 to b531fcd Compare November 6, 2024 05:12
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers
No reviews
Assignees
No one assigned
Labels
renovate upgrade Any kind of dependency updates
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
0 participants