march-hare 0.13.8 → 0.13.11

package/dist/types/index.d.ts

@@ -9,11 +9,11 @@ import * as React from "react";
  * Bounded recursion depths for {@link Inspect}. Matches Immertation's
  * `DepthLimiter` shape so the two stay in lock-step.
  */
-type DepthLimiter = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+type DepthLimiter = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
 /** Union of all keys across each arm of `T`. */
-type UnionKeys<T> = T extends T ? keyof T : never;
+type UnionKeys<T> = T extends unknown ? keyof T : never;
 /** The value at `K` for each arm of `T`, falling back to `undefined` if `K` is absent on that arm. */
-type ValueAt<T, K extends PropertyKey> = T extends T ? K extends keyof T ? T[K] : undefined : never;
+type ValueAt<T, K extends PropertyKey> = T extends unknown ? K extends keyof T ? T[K] : undefined : never;
 /**
  * March-hare's `Inspect<T>` wraps Immertation's so that property
  * navigation works when `T` is a discriminated union (e.g. the App's
@@ -23,7 +23,7 @@ type ValueAt<T, K extends PropertyKey> = T extends T ? K extends keyof T ? T[K]
  *
  * For a single concrete `T`, the wrapper is transparent.
  */
-export type Inspect<T, D extends number = 12> = ImmInspect<T> & ([D] extends [0] ? object : {
+export type Inspect<T, D extends number = 8> = ImmInspect<T> & ([D] extends [0] ? object : {
     [K in UnionKeys<T> as ValueAt<T, K> extends (...args: unknown[]) => unknown ? never : K]: Inspect<ValueAt<T, K>, DepthLimiter[D]>;
 });
 /**
@@ -175,9 +175,10 @@ export declare class Brand {
     static readonly Name: unique symbol;
     /**
      * Phantom brand identifying lifecycle actions returned by
-     * `Lifecycle.Mount()`, `Lifecycle.Unmount()`, `Lifecycle.Error()`, and
-     * `Lifecycle.Update()`. Carries the lifecycle's literal kind so that
-     * `useAction` can pick distinct overloads &mdash; in particular,
+     * `Lifecycle.Mount()`, `Lifecycle.Paint()`, `Lifecycle.Unmount()`,
+     * `Lifecycle.Error()`, and `Lifecycle.Update()`. Carries the lifecycle's
+     * literal kind so that `useAction` can pick distinct overloads &mdash; in
+     * particular,
      * `Lifecycle.Update` resolves its payload to `Partial<DeepReadonly<D>>`
      * against the surrounding `useActions` data generic instead of the
      * factory-level `Record<string, unknown>` placeholder. Without this
@@ -213,6 +214,7 @@ export declare const EnvSymbol: unique symbol;
  * ```ts
  * export class Actions {
  *   static Mount = Lifecycle.Mount();
+ *   static Paint = Lifecycle.Paint();
  *   static Unmount = Lifecycle.Unmount();
  *   static Error = Lifecycle.Error();
  *   static Update = Lifecycle.Update();
@@ -229,6 +231,14 @@ export declare const EnvSymbol: unique symbol;
 export declare class Lifecycle {
     /** Creates a Mount lifecycle action. Triggered once on component mount (`useLayoutEffect`). */
     static Mount(): LifecyclePayload<never, never, "Mount">;
+    /**
+     * Creates a Paint lifecycle action. Triggered once after the browser has
+     * committed the first frame (`useEffect`). Pairs with {@link Lifecycle.Mount}
+     * (pre-paint) &mdash; use Paint for work that should not delay the first
+     * paint: analytics &ldquo;viewed&rdquo; events, focus management, scroll-into-view,
+     * non-blocking prefetch, etc.
+     */
+    static Paint(): LifecyclePayload<never, never, "Paint">;
     /** Creates an Unmount lifecycle action. Triggered when the component unmounts. */
     static Unmount(): LifecyclePayload<never, never, "Unmount">;
     /** Creates an Error lifecycle action. Triggered when an action throws. Receives `Fault` as payload. */
@@ -407,20 +417,21 @@ export type HandlerPayload<P = unknown, C extends Filter = never, Name extends s
     (channel: C): ChanneledAction<P, C, Name>;
 });
 /**
- * Branded type returned by `Lifecycle.Mount`, `Lifecycle.Unmount`,
- * `Lifecycle.Error`, and `Lifecycle.Update`. Structurally identical to a
- * `HandlerPayload` but carries a phantom `Brand.Lifecycle` brand whose value
- * is the lifecycle's literal kind. The brand is what lets `useAction` and
- * `Handlers` resolve `Lifecycle.Update`'s payload to `Partial<DeepReadonly<D>>`
- * (against the surrounding `useActions` data generic) instead of the
- * factory-level `Record<string, unknown>` placeholder &mdash; a user-defined
- * `Action<P>("Update")` would have `Name = "Update"` but no `Brand.Lifecycle`,
- * so it falls into the generic payload overload as expected.
+ * Branded type returned by `Lifecycle.Mount`, `Lifecycle.Paint`,
+ * `Lifecycle.Unmount`, `Lifecycle.Error`, and `Lifecycle.Update`.
+ * Structurally identical to a `HandlerPayload` but carries a phantom
+ * `Brand.Lifecycle` brand whose value is the lifecycle's literal kind. The
+ * brand is what lets `useAction` and `Handlers` resolve `Lifecycle.Update`'s
+ * payload to `Partial<DeepReadonly<D>>` (against the surrounding `useActions`
+ * data generic) instead of the factory-level `Record<string, unknown>`
+ * placeholder &mdash; a user-defined `Action<P>("Update")` would have
+ * `Name = "Update"` but no `Brand.Lifecycle`, so it falls into the generic
+ * payload overload as expected.
  *
  * @template P Payload type for the lifecycle.
  * @template C Channel filter (always `never` for lifecycles &mdash; they are
  *   not channeled).
- * @template Name Literal name (`"Mount"`, `"Unmount"`, `"Error"`, `"Update"`).
+ * @template Name Literal name (`"Mount"`, `"Paint"`, `"Unmount"`, `"Error"`, `"Update"`).
  */
 export type LifecyclePayload<P = unknown, C extends Filter = never, Name extends string = string> = HandlerPayload<P, C, Name> & {
     readonly [Brand.Lifecycle]: Name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-hare",
-  "version": "0.13.8",
+  "version": "0.13.11",
   "type": "module",
   "license": "MIT",
   "packageManager": "yarn@1.22.22",
@@ -24,7 +24,7 @@
     "figlet": "^1.7.0",
     "find-up": "^8.0.0",
     "gray-matter": "^4.0.3",
-    "immertation": "^0.1.31",
+    "immertation": "^0.1.32",
     "kleur": "^4.1.5",
     "tinyglobby": "^0.2.17"
   },