Alle sites
Data API
Github Data API
Gestructureerde JSON-data op aanvraag, met ingebouwde anti-bot-bypass.
8 endpointsRate limit voor je afgehandeld
Voorbeeld (live vastgelegd) Playground openen
github.com
VoorbeeldJSON-antwoordklik op de pagina om een veld te traceren
{
"full_name": "facebook/react",
"commits": [
{
"sha": "63d9c806be677e9c2394696ca4a91f52e01eec6d",
"message": "[Ledgers] Add the row ID to the dedupe map (#37589)
Small refactor to prepare for Ledgers.
Changes the type of the value in object deduping map (`writtenObjects`)
from `string` (a reference to an object already written to the response)
to `{id: number, reference: string}` instead. `reference` is the same
string as before, and `id` is the row ID of the object.
The motivation is so a consumer of the dedupe map can access the row ID
of the deduped object. For Ledgers, this allows us to also reuse the
corresponding Ledger entries.
The original reference is kept in the map, too, since it encodes
additional information about the reference besides just the row id.
An alternative considered was changing the type to `string | {id:
string, reference: number}` but this results in additional type checks
whenever the map is accessed, and also means the map is no longer
monomorphic.",
"author_name": "Andrew Clark",
"author_login": "acdlite",
"date": "2026-11-18T19:00:37Z",
"url": "https://github.com/react/react/commit/63d9c806be677e9c2394696ca4a91f52e01eec6d",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "452c22cae121f087fe3b428d9b841bdab0d8f9bd",
"message": "[Ledgers] Scaffold Flight Ledgers behind a flag (#37588)
Sets up a feature flag for an upcoming experiment in Flight (RSC) called
Ledgers. A Ledger is an accumulated value determined as an effect of
rendering, representing some fact about the components that were
rendered. For example, a practical use case is tracking which route
parameters were accessed by the components in a response; every time a
component accesses a param, a ledger is updated. The result of a ledger
can only be read by the Flight client, and only once the stream has
closed.
Additional details will be shared in subsequent PRs.",
"author_name": "Andrew Clark",
"author_login": "acdlite",
"date": "2026-11-18T19:00:37Z",
"url": "https://github.com/react/react/commit/452c22cae121f087fe3b428d9b841bdab0d8f9bd",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "6ff257439b3919fc8dcc643b635e09d62fa74d0e",
"message": "[DevTools] Expose Suspense suspended state in facade inspection results (#38227)
## Summary
`react-devtools-facade`'s `NodeInfo` gains an always-present `meta`
field that carries info specific to built-in component types. Keeping it
always present (never optional) preserves a single hidden class for
`NodeInfo`. The `meta` type can be refined based on the Component type.
Suspense boundaries use the meta field to exposes whether they're
suspended. It has the same downside as the DevTools extension where we
treat dehydrated boundaries as suspended even though we can't know. A
dehydrated boundary can show its fallback or content.
## How did you test this change?
- added tests for both suspended states
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-authored-by: Sarah Drasner <[email protected]>
Co-authored-by: Claude Code (kimi-k3) <[email protected]>",
"author_name": "Sebastian "Sebbie" Silbermann",
"author_login": "eps1lon",
"date": "2026-11-17T17:25:22Z",
"url": "https://github.com/react/react/commit/6ff257439b3919fc8dcc643b635e09d62fa74d0e",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "a8342585c75bebaaca5d73e3724f4744e940ec09",
"message": "[React Compiler] fix: don't outline 'use no memo' functions and don't recurse into them (#38278)
> [!NOTE]
> This pull request was authored by AI on behalf of @tjzel.
> [!IMPORTANT]
> This reopens #36983, which the stale bot closed on 2026-11-15 after it
got no review. It is the same branch with the same change, now merged
with the latest `main`. I could not reopen the original pull request
myself, so I opened this one instead.
## Human track
### Why
This is a bug fix. The function outlining pass of React Compiler goes
into functions that are marked with `'use no memo'` (or `'use no
forget'`) and outlines the functions inside them. A function with an
opt-out directive should not be changed by the compiler.
### How
The outlining pass now checks the directives of each function expression
and object method it visits. When the function has an opt-out directive,
the pass skips it: it does not outline the function and does not go into
it, so the functions inside it stay in place too.
The change is made in both implementations of the pass, the TypeScript
one and the Rust one. The Rust list of opt-out directives moved to the
HIR crate, so that the outlining pass can use the same list as the entry
point.
### Testing
Existing fixtures did not cover this case, so I added two:
- `outline-functions-skip-use-no-memo`: an arrow function with `'use no
memo'` next to a plain arrow function. Only the plain one is outlined.
- `outline-functions-skip-object-method-use-no-memo`: an object method
with `'use no memo'` that has an inner function. Nothing is outlined.
Run locally on this branch after the merge with `main`:
- Both fixtures pass with the TypeScript backend (`yarn snap -p
'outline-functions-skip*'`).
- Both fixtures pass with the Rust backend (`yarn snap --rust -p
'outline-functions-skip*'`).
- `cargo check` passes for the three changed crates.
I did not run the full compiler test suite locally. CI covers it.
### Performance
No measurement was done. The change adds one directive check for each
function expression and object method that the outlining pass visits,
and it removes work for functions that are opted out.
### Alternatives
No other approach was tried. The check is placed in the outlining pass
because that pass is the one that visits nested functions on its own.
## Agent track
<details>
<summary>Details for agents</summary>
### Relation to #36983
- Same head branch: `tjzel:@tjzel/opt-out-outline`.
- #36983 was marked stale on 2026-11-08 and closed by `github-actions`
on 2026-11-15. It had no review.
- Reopening #36983 as the author failed with `Could not open the pull
request. (reopenPullRequest)`.
- Since #36983, the branch only got merge commits from `main`. There
were no conflicts.
### Changed files
-
`compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineFunctions.ts`:
before the recursive call for `FunctionExpression` and `ObjectMethod`,
`continue` when `value.loweredFunc.func.directives` has an entry of
`OPT_OUT_DIRECTIVES` (imported from `../Entrypoint`). The `continue`
also skips the outlining branch below the recursion.
-
`compiler/crates/react_compiler_optimization/src/outline_functions.rs`:
the same check in the `InstructionValue::FunctionExpression` arm (before
the outlining conditions) and in the `InstructionValue::ObjectMethod`
arm (before `Action::Recurse`).
- `compiler/crates/react_compiler_hir/src/lib.rs`: new `pub const
OPT_OUT_DIRECTIVES: &[&str] = &["use no forget", "use no memo"];`.
- `compiler/crates/react_compiler/src/entrypoint/program.rs`: the
private `OPT_OUT_DIRECTIVES` constant is removed and imported from
`react_compiler_hir`.
-
`compiler/packages/babel-plugin-react-compiler/docs/passes/37-outlineFunctions.md`:
documents the new input condition and adds an "Opt-Out Directives"
example.
- Four fixture files (`.js` and `.expect.md` for each of the two
fixtures) in
`compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/`.
### Fixture inputs
`outline-functions-skip-use-no-memo.js`:
```js
function Component(props) {
const optedOut = x => {
'use no memo';
const inner = y => y + 1;
return inner(x);
};
const outlined = x => x * 2;
return [optedOut(props.value), outlined(props.value)];
}
```
`outline-functions-skip-object-method-use-no-memo.js`:
```js
function Component(props) {
const obj = {
process(x) {
'use no memo';
const inner = y => y + 1;
return inner(x);
},
};
return obj.process(props.value);
}
```
### Local test results
```
$ yarn snap -p 'outline-functions-skip*' -v
PASS outline-functions-skip-use-no-memo
PASS outline-functions-skip-object-method-use-no-memo
2 Tests, 2 Passed, 0 Failed
$ yarn snap --rust -p 'outline-functions-skip*' -v
PASS outline-functions-skip-use-no-memo
PASS outline-functions-skip-object-method-use-no-memo
2 Tests, 2 Passed, 0 Failed
$ cargo check -p react_compiler -p react_compiler_hir -p react_compiler_optimization
Finished `dev` profile
```
These ran with Node 22.14.0, while `.nvmrc` asks for 24.22.1. The `main`
commits merged after these runs do not change compiler sources (only
`compiler/apps/playground/yarn.lock` under `compiler/`).
### Not verified
- The full `yarn snap` suite and the full Rust test suite were not run
locally.
- No benchmark was run.
</details>",
"author_name": "Tomasz Żelawski",
"author_login": "tjzel",
"date": "2026-11-17T12:56:07Z",
"url": "https://github.com/react/react/commit/a8342585c75bebaaca5d73e3724f4744e940ec09",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "1cd5eb8e0edb0b3a1ba33de9c886d91627f8b5ac",
"message": "Fix useDeferredValue regressions from #38266 (#38270)
## Summary
Fixes the two regressions from #38266 that @samselikoff reproduced in
#38268. This PR includes his test commit, so it supersedes #38268.
- **Inspecting older versions of React:** DevTools inspects whatever
React version is on the page, and older versions store the deferred
value directly instead of in a `{value, isInitial}` wrapper.
`ReactDebugHooks` now checks the shape of the hook state, the same way
it already handles other differences between versions (for example,
`dependencies` vs. `dependencies_old`). A version check isn't an option:
debug-tools doesn't receive the version, and canary builds before and
after #38266 share the same version number. The caveat, noted in a
comment, is that on an older version, a deferred value that is itself an
object with an `isInitial` property is mistaken for the wrapper.
- **Leaving the initial state:** If the final value committed while
`initialValue` was omitted, the update path took the ordinary bailout
for an identical value, which didn't clear `isInitial`. A later
`initialValue` was then shown again even though the final value had
already committed. The hook now leaves its initial state whenever the
value matches the initial value that's shown, whether or not
`initialValue` is passed.
## How did you test this change?
- The three tests from #38268 fail on `main` and pass with this change.
- Added tests for the paths the fix touches: omitting `initialValue`
before the final value commits keeps the hook in its initial state, so a
later `initialValue` still replaces the preview; and DevTools inspects a
current version of React correctly both while it shows the initial value
and when the deferred value is an object with its own `isInitial`
property. Each fails when its code path is broken.
- `ReactDeferredValue`, `ReactHooks*`, `Activity*`, and
`react-debug-tools` on experimental and stable
- `ReactDeferredValue` and `react-debug-tools` on www-modern
(`--variant=true/false`) and with `--prod`
- `yarn flow dom-node`
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Sam Selikoff <[email protected]>
Co-authored-by: Claude <[email protected]>",
"author_name": "Andrew Clark",
"author_login": "acdlite",
"date": "2026-11-17T01:15:24Z",
"url": "https://github.com/react/react/commit/1cd5eb8e0edb0b3a1ba33de9c886d91627f8b5ac",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "976e87ce22e417ae87395d4d0a5488eba3b07b02",
"message": "Fix uDV: Re-render while in "initial" state (#38266)
Resubmission of #34377, which was closed by accident. It's rebased onto
current `main`, and it also updates `ReactDebugHooks` to read the new
hook state shape, which was the failing debug-tools tests in the
original PR.
## Summary
Unlike `useState`, the `initialValue` option to `useDeferredValue` is
reactive — if the hook re-renders with a different initial value before
the final value commits, React should update to the new initial value.
To implement this, we need to track some extra state that represents
whether the hook's currently rendered value is an "initial" one. The
state is flipped to `false` when the canonical value renders for the
first time, and remains false for the rest of the component's lifetime
(or until the component's visibility is toggled by an Activity
boundary).
## How did you test this change?
- The original test, "can update initial value in place if final value
hasn't committed yet", fails on `main` and passes with this change.
- Added "transition re-render while still showing initial value does not
suspend on the pending final value". On `main`, a transition that
re-renders the hook while it still shows its initial value suspends on
the pending final value and never commits.
- `ReactDeferredValue` and `react-debug-tools` on experimental, stable,
and www-modern (`--variant=true/false`)
- `ReactHooks*` and `Activity*` on experimental
- `yarn flow dom-node`
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-authored-by: Claude <[email protected]>",
"author_name": "Andrew Clark",
"author_login": "acdlite",
"date": "2026-11-16T20:28:12Z",
"url": "https://github.com/react/react/commit/976e87ce22e417ae87395d4d0a5488eba3b07b02",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "e358bedd839c99034ffef454030523bd73d225fd",
"message": "Fix useDeferredValue lost ping when the deferred render suspends (#38265)
## Summary
When a render suspends after `useDeferredValue` returned its
`initialValue`, React spawns a deferred lane and renders the final
value. That lane is entangled with the original lanes so it includes the
same updates. If the deferred render also suspends, `markRootSuspended`
marked the entangled lanes as suspended, which cleared any ping they had
received in the meantime.
That ping is meaningful, though: the deferred render shows the final
values, so it never retried whatever the original render suspended on.
If the initial value's data resolved before or during the deferred
render, React lost the ping, and the initial value didn't commit until
the final value's data also arrived. Without a Suspense boundary, this
could block the update indefinitely.
Now a deferred render marks only its own lanes as suspended. The lanes
that spawned it are marked warm, the same as before, since the deferred
render counts as having prewarmed them, but they aren't marked suspended
and their pings are kept.
## How did you test this change?
Added two tests to `ReactDeferredValue-test.js`, where the initial
value's data resolves during the deferred render and before it starts.
Both fail on `main`.
- `yarn test` for `ReactDeferredValue`, `ReactSuspenseWithNoopRenderer`,
`ReactTransition`, `ReactIncrementalUpdates`, `ReactSuspense*`,
`ActivitySuspense`, `ReactAsyncActions`, `ReactUse` on experimental,
stable, and www-modern (`--variant=true/false`)
- `yarn test packages/react-reconciler` (experimental and stable)
- `ReactDOMServerPartialHydration`, `ReactDOMFizzDeferredValue`,
`ReactDOMFizzServer` (one `[GATED, SHOULD FAIL]` LegacyHidden failure,
also on `main`)
- `yarn flow dom-node`
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-authored-by: Claude <[email protected]>",
"author_name": "Andrew Clark",
"author_login": "acdlite",
"date": "2026-11-16T20:26:05Z",
"url": "https://github.com/react/react/commit/e358bedd839c99034ffef454030523bd73d225fd",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
},
{
"sha": "6c6f84fff59a9a3d4b433517409af151d2551b39",
"message": "[Flight] Tag Server Component performance measures with React metadata (#38135)
Adds `detail.react` to Flight's Server Component render and await
measures so tooling can read metadata without parsing names or tooltips:
```js
{
version: 1,
requestId,
kind: 'component' | 'await',
outcome: 'completed' | 'errored' | 'aborted',
environment,
}
```
The DEV-only `unstable_requestId` option on `react-server-dom-*` client
entry points (`createFromFetch`, `createFromReadableStream`, and
`createFromNodeStream`, where supported) associates measures with the
response that produced them.
The integration test checks concurrent stream and fetch responses in
webpack and Turbopack, matching each measure's request ID to its
component props.
## Validation
- Full default development suite on Node 24.22.1: 331 suites passed,
7,064 tests passed, 23 skipped, 302 snapshots passed.
- Swapping the request IDs makes both integration cases fail at the
attribution assertion.
---------
Co-authored-by: Claude <[email protected]>",
"author_name": "Will Binns-Smith",
"author_login": "wbinnssmith",
"date": "2026-11-16T18:49:10Z",
"url": "https://github.com/react/react/commit/6c6f84fff59a9a3d4b433517409af151d2551b39",
"scraped_at": "2026-11-19T10:47:31.330056+00:00"
}
]
}
GET
/v1/github/repos/{owner}/{repo}/commits1 credit / run GeverifieerdRepository Commits
Recent commits on a repository's default branch.
Voor je afgehandeld:Rate limit
Parameters
| Naam | Type | Verpl. | Omschrijving |
|---|---|---|---|
| owner | string | ja | Repository owner. |
| repo | string | ja | Repository name. |
| Geavanceerde filters | |||
| limit | integer | nee | Commits per page, 1-100. (standaard: 30) |