@kiwa-test/component 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -24,9 +24,14 @@ __export(index_exports, {
   addHandler: () => addHandler,
   appendChild: () => appendChild,
   applyOptimisticUpdate: () => applyOptimisticUpdate,
+  applyReactActionOptimistic: () => applyOptimisticUpdate2,
   assertAnimation: () => assertAnimation,
   assertMode: () => assertMode,
+  assertStaticBoundary: () => assertStaticBoundary,
+  beginActionTransition: () => beginActionTransition,
+  beginIslandHydration: () => beginIslandHydration,
   beginRscRender: () => beginRscRender,
+  bootstrapIslandsRoute: () => bootstrapIslandsRoute,
   buildButton: () => buildButton,
   buildCard: () => buildCard,
   buildForm: () => buildForm,
@@ -50,12 +55,16 @@ __export(index_exports, {
   finishElementTransition: () => finishElementTransition,
   fireEvent: () => fireEvent,
   hashMarkup: () => hashMarkup,
+  initializeReactActions: () => initializeReactActions,
   markFormStatusPending: () => markFormStatusPending,
+  markIslandInteractive: () => markIslandInteractive,
   markSuspensePending: () => markSuspensePending,
   providerEventName: () => providerEventName,
   query: () => query,
+  registerIsland: () => registerIsland,
   rejectFormAction: () => rejectFormAction,
   renderMarkup: () => renderMarkup,
+  resolveAction: () => resolveAction,
   resolveAllModes: () => resolveAllModes,
   resolveFormAction: () => resolveFormAction,
   resolveMode: () => resolveMode,
@@ -1190,6 +1199,19 @@ var COMPONENT_AXIS_TO_EVENTS = {
     "form.optimistic_applied",
     "form.progressive_enhanced",
     "form.action_resolved"
+  ],
+  // v1.49 advanced III
+  "react-19-actions": [
+    "action.state_initialized",
+    "action.transition_pending",
+    "action.optimistic_committed",
+    "action.resolved"
+  ],
+  "islands-architecture": [
+    "islands.registered",
+    "islands.hydration_started",
+    "islands.interactive_ready",
+    "islands.static_boundary_asserted"
   ]
 };
 function collectFidelityCoverage(providers = ["storybook8", "playwright-ct", "chromatic"]) {
@@ -1209,6 +1231,147 @@ function collectFidelityCoverage(providers = ["storybook8", "playwright-ct", "ch
   return { providers, axes, rows };
 }
 
+// src/semantics/react-19-actions.ts
+function emit5(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { actionId: session.actionId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+function initializeReactActions(input) {
+  if (input.actionId.length === 0) {
+    throw new Error("initializeReactActions: actionId must not be empty");
+  }
+  const session = {
+    target: input.target,
+    actionId: input.actionId,
+    state: "idle",
+    pendingCount: 0,
+    optimisticValues: [],
+    resolvedValue: null,
+    history: []
+  };
+  emit5(session, "action.state_initialized", { pendingCount: 0 });
+  return session;
+}
+function beginActionTransition(session) {
+  if (session.state !== "idle" && session.state !== "resolved") {
+    throw new Error(`beginActionTransition: session is ${session.state}`);
+  }
+  session.state = "transition-pending";
+  session.pendingCount += 1;
+  return emit5(session, "action.transition_pending", {
+    pendingCount: session.pendingCount
+  });
+}
+function applyOptimisticUpdate2(session, optimisticValue) {
+  if (session.state !== "transition-pending") {
+    throw new Error(`applyOptimisticUpdate: session is ${session.state}`);
+  }
+  session.state = "optimistic-committed";
+  session.optimisticValues.push(optimisticValue);
+  return emit5(session, "action.optimistic_committed", { optimisticValue });
+}
+function resolveAction(session, resolvedValue) {
+  if (session.state !== "transition-pending" && session.state !== "optimistic-committed") {
+    throw new Error(`resolveAction: session is ${session.state}`);
+  }
+  session.state = "resolved";
+  session.resolvedValue = resolvedValue;
+  session.pendingCount = Math.max(0, session.pendingCount - 1);
+  return emit5(session, "action.resolved", {
+    resolvedValue,
+    pendingCount: session.pendingCount,
+    optimisticCount: session.optimisticValues.length
+  });
+}
+
+// src/semantics/islands-architecture.ts
+function emit6(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { routeId: session.routeId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+function bootstrapIslandsRoute(input) {
+  if (input.routeId.length === 0) {
+    throw new Error("bootstrapIslandsRoute: routeId must not be empty");
+  }
+  return {
+    target: input.target,
+    routeId: input.routeId,
+    islands: [],
+    state: "idle",
+    hydratedIslandIds: [],
+    staticBoundaryIds: [],
+    history: []
+  };
+}
+function registerIsland(session, island) {
+  session.islands.push(island);
+  session.state = "registered";
+  return emit6(session, "islands.registered", {
+    islandId: island.islandId,
+    loadStrategy: island.loadStrategy,
+    interactiveBoundary: island.interactiveBoundary
+  });
+}
+function beginIslandHydration(session, islandId) {
+  const island = session.islands.find((i) => i.islandId === islandId);
+  if (!island) {
+    throw new Error(`beginIslandHydration: island ${islandId} not registered`);
+  }
+  if (session.state !== "registered" && session.state !== "hydrating") {
+    throw new Error(`beginIslandHydration: session is ${session.state}`);
+  }
+  session.state = "hydrating";
+  return emit6(session, "islands.hydration_started", {
+    islandId,
+    loadStrategy: island.loadStrategy
+  });
+}
+function markIslandInteractive(session, islandId) {
+  if (session.state !== "hydrating") {
+    throw new Error(`markIslandInteractive: session is ${session.state}`);
+  }
+  if (session.hydratedIslandIds.includes(islandId)) {
+    throw new Error(`markIslandInteractive: island ${islandId} already interactive`);
+  }
+  session.hydratedIslandIds.push(islandId);
+  const allHydrated = session.hydratedIslandIds.length === session.islands.filter((i) => i.interactiveBoundary).length;
+  if (allHydrated) {
+    session.state = "interactive";
+  }
+  return emit6(session, "islands.interactive_ready", {
+    islandId,
+    hydratedCount: session.hydratedIslandIds.length,
+    allInteractiveReady: allHydrated
+  });
+}
+function assertStaticBoundary(session, boundaryId) {
+  if (session.staticBoundaryIds.includes(boundaryId)) {
+    throw new Error(`assertStaticBoundary: boundary ${boundaryId} already asserted`);
+  }
+  session.staticBoundaryIds.push(boundaryId);
+  if (session.state === "interactive") {
+    session.state = "static-verified";
+  }
+  return emit6(session, "islands.static_boundary_asserted", {
+    boundaryId,
+    staticBoundaryCount: session.staticBoundaryIds.length
+  });
+}
+
 // src/real-driver.ts
 var TARGET_KEY_ENV = {
   storybook8: "STORYBOOK_URL",
@@ -1247,9 +1410,14 @@ function assertMode(provider, expected, env = process.env) {
   addHandler,
   appendChild,
   applyOptimisticUpdate,
+  applyReactActionOptimistic,
   assertAnimation,
   assertMode,
+  assertStaticBoundary,
+  beginActionTransition,
+  beginIslandHydration,
   beginRscRender,
+  bootstrapIslandsRoute,
   buildButton,
   buildCard,
   buildForm,
@@ -1273,12 +1441,16 @@ function assertMode(provider, expected, env = process.env) {
   finishElementTransition,
   fireEvent,
   hashMarkup,
+  initializeReactActions,
   markFormStatusPending,
+  markIslandInteractive,
   markSuspensePending,
   providerEventName,
   query,
+  registerIsland,
   rejectFormAction,
   renderMarkup,
+  resolveAction,
   resolveAllModes,
   resolveFormAction,
   resolveMode,