@hyperframes/studio 0.6.110 → 0.6.111

package/src/utils/sdkShadowGsapFidelity.ts

@@ -1,296 +0,0 @@
-/**
- * GSAP value-fidelity shadow (serialize round-trip diff). Split out of
- * sdkShadow.ts to keep that file under the 600-line studio cap.
- *
- * Existence parity (sdkShadow.ts) confirms a tween was created/removed, but not
- * that its VALUES (duration / ease / position / properties) match the server.
- * The SDK exposes no per-tween property reader, so we compare the two writers'
- * output: apply the same op to a fresh SDK doc opened from the server's pre-op
- * file, then structurally diff the SDK's GSAP script against the server's
- * resulting script. Both are re-parsed, so formatting/whitespace differences
- * never produce false positives — only real value drift does.
- */
-
-import { openComposition } from "@hyperframes/sdk";
-import { parseGsapScriptAcorn } from "@hyperframes/core/gsap-parser-acorn";
-import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
-import { STUDIO_SDK_SHADOW_ENABLED } from "../components/editor/manualEditingAvailability";
-import { trackStudioEvent } from "./studioTelemetry";
-import { relEqual } from "./sdkShadowNumeric";
-import type { SdkShadowMismatch, ShadowGsapOp } from "./sdkShadow";
-
-// Marker set must match document.ts extractGsapScript so both pick the same
-// <script> from any given composition.
-function isGsapScriptBody(body: string): boolean {
-  return body.includes("gsap") || body.includes("__timelines") || body.includes("ScrollTrigger");
-}
-
-export function extractGsapScript(html: string): string | null {
-  // Close tag is `</script[^>]*>` (not just `</script>`) — HTML5 ignores junk
-  // before the `>`, e.g. `</script >` or `</script foo>` (CodeQL js/bad-tag-filter).
-  const scripts = html.match(/<script\b[^>]*>([\s\S]*?)<\/script[^>]*>/gi);
-  if (!scripts) return null;
-  for (const block of scripts) {
-    const body = block.replace(/^<script\b[^>]*>/i, "").replace(/<\/script[^>]*>$/i, "");
-    if (isGsapScriptBody(body)) return body;
-  }
-  return null;
-}
-
-function posKey(position: unknown): string {
-  if (typeof position === "number") return String(position);
-  const n = Number(position);
-  return Number.isNaN(n) ? String(position) : String(n);
-}
-
-// Key a tween by its RESOLVED target element (not raw selector) + method +
-// position. The SDK writer emits [data-hf-id="X"] selectors while the server
-// emits class/other selectors for the SAME element; keying by resolved element
-// matches them so the diff compares values instead of flagging present/absent.
-//
-// ponytail: one-tween-per-(element, method, position) assumption — coincident
-// tweens (same element+method+position, different props) collapse, last wins,
-// so the diff under-reports them. Props can't go in the key (a matched pair
-// must share a key for the field-diff to run; raw props would split real value
-// drift into present/absent). Not seen in studio-emitted templates; add a
-// property-NAME hash to the key if coincident tweens show up in the wild.
-function tweenKey(anim: GsapAnimation, resolveSelector?: (sel: string) => string): string {
-  const sel = resolveSelector ? resolveSelector(anim.targetSelector) : anim.targetSelector;
-  return `${sel}|${anim.method}|${posKey(anim.position)}`;
-}
-
-function animByKey(
-  script: string,
-  resolveSelector?: (sel: string) => string,
-): Map<string, GsapAnimation> {
-  const map = new Map<string, GsapAnimation>();
-  const parsed = parseGsapScriptAcorn(script);
-  for (const anim of parsed.animations) map.set(tweenKey(anim, resolveSelector), anim);
-  return map;
-}
-
-// The server (addAnimationToScript) and SDK (gsapWriterAcorn) are DIFFERENT
-// writers, so the same tween can serialize with different property key order or
-// number-vs-string forms. Compare canonically — sort keys, coerce numeric
-// strings — so only real value drift registers, not formatting differences.
-
-// Coerce string operands to numbers, then compare with the shared relative
-// epsilon (relEqual) so float-formatting noise (3.1 vs 3.0999999999999996)
-// isn't flagged as drift while a real 2 vs 1 still is.
-function numericEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  const na = typeof a === "string" ? Number(a) : a;
-  const nb = typeof b === "string" ? Number(b) : b;
-  if (typeof na !== "number" || typeof nb !== "number" || Number.isNaN(na) || Number.isNaN(nb)) {
-    return false;
-  }
-  return relEqual(na, nb);
-}
-
-function canonicalProps(obj: Record<string, unknown> | undefined): string {
-  if (!obj) return "{}";
-  const out: Record<string, unknown> = {};
-  for (const key of Object.keys(obj).sort()) {
-    const v = obj[key];
-    // normalize "0.5" → 0.5 so a number/string writer difference isn't drift
-    out[key] = typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v)) ? Number(v) : v;
-  }
-  return JSON.stringify(out);
-}
-
-/**
- * Structurally diff two GSAP scripts. Tweens are matched by resolved target
- * element + method + position (see tweenKey), so the SDK's [data-hf-id]
- * selectors and the server's class selectors for the same element don't
- * false-flag present/absent. Reports a tween present in one but not the other,
- * and per-field value drift (duration, ease, properties, fromProperties).
- * Comparison is canonical so writer formatting differences don't register.
- *
- * Pass resolveSelector (selector → canonical element id) to enable the
- * element-based matching; without it, matching falls back to raw selector.
- */
-// fallow-ignore-next-line complexity
-export function gsapFidelityMismatches(
-  sdkScript: string,
-  serverScript: string,
-  resolveSelector?: (sel: string) => string,
-): SdkShadowMismatch[] {
-  const sdk = animByKey(sdkScript, resolveSelector);
-  const server = animByKey(serverScript, resolveSelector);
-  const mismatches: SdkShadowMismatch[] = [];
-  const keys = new Set([...sdk.keys(), ...server.keys()]);
-  for (const key of keys) {
-    const a = sdk.get(key);
-    const b = server.get(key);
-    if (!a || !b) {
-      mismatches.push({
-        kind: "value_mismatch",
-        hfId: key,
-        property: "tween",
-        expected: b ? "present" : "absent",
-        actual: a ? "present" : "absent",
-      });
-      continue;
-    }
-    // method + position are part of the key (already equal); compare values.
-    const fields: Array<[string, unknown, unknown, boolean]> = [
-      ["duration", a.duration, b.duration, numericEqual(a.duration, b.duration)],
-      ["ease", a.ease, b.ease, a.ease === b.ease],
-      [
-        "properties",
-        a.properties,
-        b.properties,
-        canonicalProps(a.properties) === canonicalProps(b.properties),
-      ],
-      [
-        "fromProperties",
-        a.fromProperties,
-        b.fromProperties,
-        canonicalProps(a.fromProperties) === canonicalProps(b.fromProperties),
-      ],
-    ];
-    for (const [property, av, bv, equal] of fields) {
-      if (!equal) {
-        mismatches.push({
-          kind: "value_mismatch",
-          hfId: key,
-          property,
-          expected: bv == null ? null : JSON.stringify(bv),
-          actual: av == null ? null : JSON.stringify(av),
-        });
-      }
-    }
-  }
-  return mismatches;
-}
-
-export interface GsapFidelityArgs {
-  before: string;
-  op: ShadowGsapOp;
-  serverScript: string;
-}
-
-/**
- * Wiring gate for the commitMutation chokepoint: return the narrowed fidelity
- * args only when there is a live session, a typed shadow op, and both the
- * pre-op file and the server's resulting script to diff against (scriptText is
- * null when the composition has no GSAP script). Returns null otherwise. Pure +
- * narrowing so the wiring decision is unit-testable without rendering the hook
- * and the caller needs no non-null assertions.
- */
-export function resolveGsapFidelityArgs(
-  sdkSession: unknown,
-  shadowGsapOp: ShadowGsapOp | undefined,
-  before: string | null | undefined,
-  serverScript: string | null | undefined,
-): GsapFidelityArgs | null {
-  if (!sdkSession || !shadowGsapOp || before == null || serverScript == null) return null;
-  return { before, op: shadowGsapOp, serverScript };
-}
-
-// Resolve a CSS selector to a canonical element key using the pre-op document,
-// so tweens that target the same element via different selectors
-// ([data-hf-id="X"] vs .X vs #X) collapse to one key in the fidelity diff.
-//
-// The SDK writer emits [data-hf-id="X"] while the server may emit a class/id
-// selector for the SAME element. Keying both forms to the same node prevents a
-// false present/absent mismatch. Resolution order, for whatever element the
-// selector matches:
-//   1. data-hf-id present  → "hfid:<id>"  (the common, stable case)
-//   2. no data-hf-id       → "node:<n>"   (per-document node index; identical
-//      regardless of which selector form found the node, so .x and [data-hf-id]
-//      pointing at the same attribute-less node still collapse)
-//   3. selector resolves to no node / parse error / no DOM → the raw selector
-//      (last resort; only diverges when the two writers genuinely target
-//      different — or unresolvable — nodes, which is real drift to surface)
-// The "hfid:"/"node:" prefixes are namespaced so a canonical key can never
-// collide with a raw-selector fallback.
-//
-// ponytail: first-match heuristic — querySelector returns the FIRST match, so an
-// ambiguous selector (e.g. .x shared by two elements) may map to a different
-// node than the SDK side's [data-hf-id] target and still flag present/absent.
-// Safe for studio templates (one tween per element); upgrade to querySelectorAll
-// + uniqueness check if ambiguous selectors appear.
-export function makeSelectorResolver(html: string): (sel: string) => string {
-  let doc: Document | null = null;
-  try {
-    doc = new DOMParser().parseFromString(html, "text/html");
-  } catch {
-    doc = null;
-  }
-  // Stable per-node index so an attribute-less element keys identically no
-  // matter which selector form (class vs id vs [data-hf-id]) resolved it.
-  const nodeKeys = new WeakMap<Element, string>();
-  let nextNode = 0;
-  const keyForNode = (el: Element): string => {
-    const hfId = el.getAttribute("data-hf-id");
-    if (hfId != null && hfId !== "") return `hfid:${hfId}`;
-    const existing = nodeKeys.get(el);
-    if (existing != null) return existing;
-    const key = `node:${nextNode++}`;
-    nodeKeys.set(el, key);
-    return key;
-  };
-  return (sel) => {
-    if (!doc) return sel;
-    try {
-      const el = doc.querySelector(sel);
-      return el ? keyForNode(el) : sel;
-    } catch {
-      return sel;
-    }
-  };
-}
-
-/**
- * Shadow GSAP value fidelity: open a fresh SDK doc from the server's pre-op
- * file, apply the same tween op, serialize, and diff the SDK's GSAP script
- * against the server's resulting script. Emits sdk_shadow_dispatch op:
- * "gsap_fidelity". Async, fire-and-forget; server stays authoritative.
- */
-export async function runShadowGsapFidelity(
-  beforeHtml: string,
-  gsapOp: ShadowGsapOp,
-  serverScript: string,
-): Promise<void> {
-  if (!STUDIO_SDK_SHADOW_ENABLED) return;
-  // No server script to diff against → skip the (costly) openComposition.
-  if (!serverScript || !beforeHtml) return;
-  try {
-    const session = await openComposition(beforeHtml);
-    session.batch(() => {
-      if (gsapOp.kind === "add") session.addGsapTween(gsapOp.target, gsapOp.tween);
-      else if (gsapOp.kind === "set") session.setGsapTween(gsapOp.animationId, gsapOp.properties);
-      else session.removeGsapTween(gsapOp.animationId);
-    });
-    const sdkScript = extractGsapScript(session.serialize());
-    if (sdkScript == null) {
-      trackStudioEvent("sdk_shadow_dispatch", {
-        op: "gsap_fidelity",
-        dispatched: false,
-        reason: "no_sdk_script",
-        mismatchCount: 0,
-      });
-      return;
-    }
-    const mismatches = gsapFidelityMismatches(
-      sdkScript,
-      serverScript,
-      makeSelectorResolver(beforeHtml),
-    );
-    trackStudioEvent("sdk_shadow_dispatch", {
-      op: "gsap_fidelity",
-      dispatched: true,
-      mismatchCount: mismatches.length,
-      mismatches: JSON.stringify(mismatches),
-    });
-  } catch (err) {
-    trackStudioEvent("sdk_shadow_dispatch", {
-      op: "gsap_fidelity",
-      dispatched: false,
-      reason: "fidelity_error",
-      error: String(err),
-      mismatchCount: 0,
-    });
-  }
-}

package/src/utils/sdkShadowGsapKeyframe.test.ts

@@ -1,265 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { openComposition } from "@hyperframes/sdk";
-import {
-  resolveKeyframeIndexByPercentage,
-  keyframeOpToEditOp,
-  gsapKeyframeFidelityMismatches,
-  runShadowGsapKeyframeFidelity,
-  type ShadowKeyframeOp,
-} from "./sdkShadowGsapKeyframe";
-import { runShadowDispatch } from "./sdkShadow";
-import type { PatchOperation } from "./sourcePatcher";
-
-// Capture sdk_shadow_dispatch telemetry.
-const trackedEvents: Array<{ event: string; props: Record<string, unknown> }> = [];
-vi.mock("./studioTelemetry", () => ({
-  trackStudioEvent: (event: string, props: Record<string, unknown>) =>
-    trackedEvents.push({ event, props }),
-}));
-// STUDIO_SDK_SHADOW_ENABLED defaults true (no env override in test), so the
-// runners are active here without mocking the availability module.
-
-beforeEach(() => {
-  trackedEvents.length = 0;
-});
-const lastShadow = () =>
-  trackedEvents.filter((e) => e.event === "sdk_shadow_dispatch").at(-1)?.props;
-
-const ANIM_ID = "#hero-to-0-position";
-
-function gsapHtml(scriptBody: string): string {
-  return /* html */ `<!DOCTYPE html><html><body>
-  <div data-hf-id="hf-hero" id="hero" class="clip">x</div>
-  <script>
-${scriptBody}
-  window.__timelines = [tl];
-  </script>
-</body></html>`;
-}
-
-const KF_SCRIPT = `
-  const tl = gsap.timeline({ paused: true });
-  tl.to("#hero", { keyframes: { "0%": { x: 0 }, "50%": { x: 100 }, "100%": { x: 200 } }, duration: 5 }, 0);`;
-
-// A script body string (not full HTML) for the index-resolution helpers.
-const KF_SCRIPT_BODY = KF_SCRIPT;
-const DUP_SCRIPT_BODY = `
-  const tl = gsap.timeline({ paused: true });
-  tl.to("#hero", { keyframes: { "0%": { x: 0 }, "50%": { x: 100 }, "50%": { x: 150 }, "100%": { x: 200 } }, duration: 5 }, 0);`;
-
-describe("resolveKeyframeIndexByPercentage", () => {
-  it("resolves a unique percentage to its 0-based index", () => {
-    expect(resolveKeyframeIndexByPercentage(KF_SCRIPT_BODY, ANIM_ID, 50)).toEqual({
-      keyframeIndex: 1,
-    });
-    expect(resolveKeyframeIndexByPercentage(KF_SCRIPT_BODY, ANIM_ID, 100)).toEqual({
-      keyframeIndex: 2,
-    });
-  });
-
-  it("matches within ~0.001 tolerance", () => {
-    expect(resolveKeyframeIndexByPercentage(KF_SCRIPT_BODY, ANIM_ID, 50.0005).keyframeIndex).toBe(
-      1,
-    );
-  });
-
-  it("returns null with not_found when no percentage matches", () => {
-    expect(resolveKeyframeIndexByPercentage(KF_SCRIPT_BODY, ANIM_ID, 33)).toEqual({
-      keyframeIndex: null,
-      reason: "not_found",
-    });
-  });
-
-  it("returns null with no_keyframes for an unknown animation", () => {
-    expect(resolveKeyframeIndexByPercentage(KF_SCRIPT_BODY, "#nope-to-0", 50)).toEqual({
-      keyframeIndex: null,
-      reason: "no_keyframes",
-    });
-  });
-
-  it("returns null with no_keyframes when script is empty", () => {
-    expect(resolveKeyframeIndexByPercentage(null, ANIM_ID, 50).reason).toBe("no_keyframes");
-  });
-
-  it("no-ops on ambiguity (duplicate-percentage keyframes — PR #1498 landmine)", () => {
-    expect(resolveKeyframeIndexByPercentage(DUP_SCRIPT_BODY, ANIM_ID, 50)).toEqual({
-      keyframeIndex: null,
-      reason: "ambiguous",
-    });
-  });
-
-  // Regression: a from/fromTo tween's id may normalize to "-to-" on write, so a
-  // "-from-"/"-fromTo-" animationId must fall back to the converted id (matching
-  // the writer's locateAnimationWithFallback) — else the keyframe diff goes blind.
-  it("falls back from a -from- id to the -to- tween", () => {
-    const fromId = ANIM_ID.replace("-to-", "-from-");
-    expect(resolveKeyframeIndexByPercentage(KF_SCRIPT_BODY, fromId, 50)).toEqual({
-      keyframeIndex: 1,
-    });
-  });
-});
-
-describe("keyframeOpToEditOp", () => {
-  it("maps add → addGsapKeyframe with position = percentage", () => {
-    const op: ShadowKeyframeOp = {
-      kind: "add",
-      animationId: ANIM_ID,
-      percentage: 25,
-      properties: { x: 50 },
-    };
-    expect(keyframeOpToEditOp(op, KF_SCRIPT_BODY)).toEqual({
-      op: { type: "addGsapKeyframe", animationId: ANIM_ID, position: 25, value: { x: 50 } },
-    });
-  });
-
-  it("maps remove → removeGsapKeyframe with resolved index", () => {
-    const op: ShadowKeyframeOp = { kind: "remove", animationId: ANIM_ID, percentage: 50 };
-    expect(keyframeOpToEditOp(op, KF_SCRIPT_BODY)).toEqual({
-      op: { type: "removeGsapKeyframe", animationId: ANIM_ID, keyframeIndex: 1 },
-    });
-  });
-
-  it("returns null op + reason when remove percentage is ambiguous", () => {
-    const op: ShadowKeyframeOp = { kind: "remove", animationId: ANIM_ID, percentage: 50 };
-    expect(keyframeOpToEditOp(op, DUP_SCRIPT_BODY)).toEqual({ op: null, reason: "ambiguous" });
-  });
-});
-
-describe("gsapKeyframeFidelityMismatches", () => {
-  it("reports no mismatches when keyframe arrays match", () => {
-    expect(gsapKeyframeFidelityMismatches(KF_SCRIPT_BODY, KF_SCRIPT_BODY, ANIM_ID)).toEqual([]);
-  });
-
-  it("reports a keyframes mismatch when arrays diverge", () => {
-    const other = `
-      const tl = gsap.timeline({ paused: true });
-      tl.to("#hero", { keyframes: { "0%": { x: 0 }, "50%": { x: 999 }, "100%": { x: 200 } }, duration: 5 }, 0);`;
-    const mismatches = gsapKeyframeFidelityMismatches(KF_SCRIPT_BODY, other, ANIM_ID);
-    expect(mismatches.some((m) => m.property === "keyframes")).toBe(true);
-  });
-});
-
-describe("runShadowGsapKeyframeFidelity (add)", () => {
-  it("emits gsap_keyframe with a keyframes mismatch when SDK adds but server didn't", async () => {
-    const beforeHtml = gsapHtml(KF_SCRIPT);
-    // server script unchanged (server "failed" to add the 25% keyframe) → drift
-    const session = await openComposition(beforeHtml);
-    const serverScript = session
-      .serialize()
-      .match(/<script\b[^>]*>([\s\S]*?)<\/script[^>]*>/i)?.[1];
-    expect(serverScript).toBeTruthy();
-    const op: ShadowKeyframeOp = {
-      kind: "add",
-      animationId: ANIM_ID,
-      percentage: 25,
-      properties: { x: 50 },
-    };
-    await runShadowGsapKeyframeFidelity(beforeHtml, op, serverScript);
-    const props = lastShadow();
-    expect(props?.op).toBe("gsap_keyframe");
-    expect(props?.dispatched).toBe(true);
-    expect(props?.mismatchCount).toBe(1);
-  });
-
-  it("emits dispatched:true mismatchCount:0 when SDK and server agree", async () => {
-    const beforeHtml = gsapHtml(KF_SCRIPT);
-    // Build the server's resulting script by applying the same op via the SDK.
-    const serverSession = await openComposition(beforeHtml);
-    serverSession.batch(() =>
-      serverSession.dispatch({
-        type: "addGsapKeyframe",
-        animationId: ANIM_ID,
-        position: 25,
-        value: { x: 50 },
-      }),
-    );
-    const serverScript = serverSession
-      .serialize()
-      .match(/<script\b[^>]*>([\s\S]*?)<\/script[^>]*>/i)?.[1];
-    const op: ShadowKeyframeOp = {
-      kind: "add",
-      animationId: ANIM_ID,
-      percentage: 25,
-      properties: { x: 50 },
-    };
-    await runShadowGsapKeyframeFidelity(beforeHtml, op, serverScript);
-    const props = lastShadow();
-    expect(props?.op).toBe("gsap_keyframe");
-    expect(props?.dispatched).toBe(true);
-    expect(props?.mismatchCount).toBe(0);
-  });
-});
-
-describe("runShadowGsapKeyframeFidelity (remove)", () => {
-  it("no-ops with reason when remove percentage is ambiguous", async () => {
-    const beforeHtml = gsapHtml(DUP_SCRIPT_BODY);
-    const op: ShadowKeyframeOp = { kind: "remove", animationId: ANIM_ID, percentage: 50 };
-    await runShadowGsapKeyframeFidelity(beforeHtml, op, "non-empty-server-script gsap");
-    const props = lastShadow();
-    expect(props?.op).toBe("gsap_keyframe");
-    expect(props?.dispatched).toBe(false);
-    expect(props?.reason).toBe("ambiguous");
-  });
-
-  it("dispatches a resolved remove and diffs", async () => {
-    const beforeHtml = gsapHtml(KF_SCRIPT);
-    const serverSession = await openComposition(beforeHtml);
-    serverSession.batch(() =>
-      serverSession.dispatch({
-        type: "removeGsapKeyframe",
-        animationId: ANIM_ID,
-        keyframeIndex: 1,
-      }),
-    );
-    const serverScript = serverSession
-      .serialize()
-      .match(/<script\b[^>]*>([\s\S]*?)<\/script[^>]*>/i)?.[1];
-    const op: ShadowKeyframeOp = { kind: "remove", animationId: ANIM_ID, percentage: 50 };
-    await runShadowGsapKeyframeFidelity(beforeHtml, op, serverScript);
-    const props = lastShadow();
-    expect(props?.op).toBe("gsap_keyframe");
-    expect(props?.dispatched).toBe(true);
-    expect(props?.mismatchCount).toBe(0);
-  });
-});
-
-describe("runShadowGsapKeyframeFidelity (guards)", () => {
-  it("skips when there is no server script", async () => {
-    const op: ShadowKeyframeOp = {
-      kind: "add",
-      animationId: ANIM_ID,
-      percentage: 25,
-      properties: { x: 50 },
-    };
-    await runShadowGsapKeyframeFidelity(gsapHtml(KF_SCRIPT), op, null);
-    expect(lastShadow()).toBeUndefined();
-  });
-});
-
-describe("runShadowDispatch unmapped-type guard", () => {
-  const ELEMENT_HTML = /* html */ `<!DOCTYPE html><html><body>
-    <div data-hf-id="hf-box" style="color: red;">Hi</div>
-  </body></html>`;
-
-  it("emits unmapped_type when a PatchOperation type isn't mapped", async () => {
-    const session = await openComposition(ELEMENT_HTML);
-    // PatchOperation.type is a closed union today; cast to exercise the defensive
-    // guard for a future unmapped type.
-    const ops = [{ type: "future-op", property: "x", value: "1" } as unknown as PatchOperation];
-    runShadowDispatch(session, { hfId: "hf-box" } as never, ops);
-    const props = lastShadow();
-    expect(props?.op).toBe("property");
-    expect(props?.dispatched).toBe(false);
-    expect(props?.reason).toBe("unmapped_type");
-    expect(props?.type).toBe("future-op");
-  });
-
-  it("dispatches normally for known PatchOperation types", async () => {
-    const session = await openComposition(ELEMENT_HTML);
-    const ops: PatchOperation[] = [{ type: "inline-style", property: "color", value: "#00f" }];
-    runShadowDispatch(session, { hfId: "hf-box" } as never, ops);
-    const props = lastShadow();
-    expect(props?.dispatched).toBe(true);
-    expect(props?.reason).toBeUndefined();
-  });
-});