@reckona/mreact-compat 0.0.159 → 0.0.161

package/src/scheduler.ts

@@ -14,29 +14,41 @@ import {
   type SchedulerTask,
 } from "./fiber-scheduler.js";
 
+/** Numeric priority level used by the scheduler-compatible API. */
 export type unstable_PriorityLevel = 1 | 2 | 3 | 4 | 5;
+/** Handle returned by unstable_scheduleCallback. */
 export type unstable_CallbackNode = SchedulerTask;
+/** Scheduled callback that may return a continuation. */
 export type unstable_Callback = (
   didTimeout: boolean,
 ) => unstable_Callback | null | void;
 
+/** Highest-priority scheduler task for immediate work. */
 export const unstable_ImmediatePriority = 1;
+/** Scheduler priority for user-blocking work. */
 export const unstable_UserBlockingPriority = 2;
+/** Scheduler priority for normal work. */
 export const unstable_NormalPriority = 3;
+/** Scheduler priority for low-priority work. */
 export const unstable_LowPriority = 4;
+/** Scheduler priority for idle work. */
 export const unstable_IdlePriority = 5;
+/** Profiling controls for scheduler-compatible tracing. */
 export const unstable_Profiling = {
   startLoggingProfilingEvents: startLoggingSchedulerProfilingEvents,
   stopLoggingProfilingEvents: stopLoggingSchedulerProfilingEvents,
 };
+/** Profiling event emitted by scheduler-compatible tracing. */
 export type unstable_ProfilingEvent = SchedulerProfilingEvent;
 
 let currentPriorityLevel: unstable_PriorityLevel = unstable_NormalPriority;
 
+/** Returns the scheduler clock time in milliseconds. */
 export function unstable_now(): number {
   return now();
 }
 
+/** Schedules a callback at the requested scheduler priority. */
 export function unstable_scheduleCallback(
   priorityLevel: unstable_PriorityLevel,
   callback: unstable_Callback,
@@ -49,26 +61,32 @@ export function unstable_scheduleCallback(
   );
 }
 
+/** Cancels a scheduled callback node. */
 export function unstable_cancelCallback(task: unstable_CallbackNode): void {
   cancelCallback(task);
 }
 
+/** Returns true when the current scheduler task should yield to the host. */
 export function unstable_shouldYield(): boolean {
   return shouldYieldToHost();
 }
 
+/** Requests a paint opportunity from the host scheduler. */
 export function unstable_requestPaint(): void {
   requestPaint();
 }
 
+/** Sets the target frame rate for scheduler yielding. */
 export function unstable_forceFrameRate(fps: number): void {
   forceFrameRate(fps);
 }
 
+/** Returns the priority currently active for scheduler-compatible callbacks. */
 export function unstable_getCurrentPriorityLevel(): unstable_PriorityLevel {
   return currentPriorityLevel;
 }
 
+/** Runs a callback at the requested scheduler priority. */
 export function unstable_runWithPriority<T>(
   priorityLevel: unstable_PriorityLevel,
   callback: () => T,
@@ -76,6 +94,7 @@ export function unstable_runWithPriority<T>(
   return runWithPriorityLevel(priorityLevel, callback);
 }
 
+/** Runs a callback at normal priority when the current priority is higher. */
 export function unstable_next<T>(callback: () => T): T {
   const nextPriority =
     currentPriorityLevel === unstable_ImmediatePriority ||
@@ -85,6 +104,7 @@ export function unstable_next<T>(callback: () => T): T {
   return runWithPriorityLevel(nextPriority, callback);
 }
 
+/** Wraps a callback so it runs later with the current scheduler priority. */
 export function unstable_wrapCallback<TArgs extends unknown[], TResult>(
   callback: (...args: TArgs) => TResult,
 ): (...args: TArgs) => TResult {
@@ -92,14 +112,17 @@ export function unstable_wrapCallback<TArgs extends unknown[], TResult>(
   return (...args) => runWithPriorityLevel(capturedPriority, () => callback(...args));
 }
 
+/** Returns the first pending scheduler callback node, if one exists. */
 export function unstable_getFirstCallbackNode(): unstable_CallbackNode | null {
   return getFirstCallbackNode();
 }
 
+/** Compatibility no-op for pausing global scheduler execution. */
 export function unstable_pauseExecution(): void {
   // React exposes this as an unstable public hook; this scheduler has no global pause state.
 }
 
+/** Compatibility no-op for resuming global scheduler execution. */
 export function unstable_continueExecution(): void {
   // Host callbacks are requested eagerly by scheduleCallback, so there is no paused queue to resume.
 }

package/src/server-render.ts

@@ -34,6 +34,7 @@ import {
 import { escapeHtmlAttribute as escapeHtml } from "@reckona/mreact-shared/html-escape";
 import { isVoidHtmlElement } from "@reckona/mreact-shared";
 
+/** Renders a React-compatible component to an HTML string. */
 export function renderToString<TProps>(
   component:
     | ((props: TProps) => ReactCompatNode)