Перейти к содержимому
Все сайты
Data API

Github Data API

Структурированные JSON-данные по запросу со встроенным обходом антибот-защиты.

8 эндпоинтовЛимит запросов: мы берём это на себя
github.comGET/github/repos/…GET/github/repos/…GET/github/repos/…{ } JSON
Пример (получен вживую) Открыть песочницу
github.com
Пример
JSON-ответнажмите на страницу, чтобы отследить поле
{
"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 кредит / запуск Проверено

Repository Commits

Recent commits on a repository's default branch.

Мы берём на себя:Лимит запросов
Параметры
НазваниеТипОбяз.Описание
ownerstringдаRepository owner.
repostringдаRepository name.
Расширенные фильтры
limitintegerнетCommits per page, 1-100. (по умолчанию: 30)