@kiwa-test/nextjs 1.0.5 → 1.2.0

package/dist/index.js

@@ -241,19 +241,560 @@ async function invokeParallelRoutes(opts) {
   }
   return { tree, slotResults, childrenError, layoutError };
 }
+
+// src/setup-next-rsc-env.ts
+var RSC_ERROR_BOUNDARY_SYMBOL = /* @__PURE__ */ Symbol.for("kiwa.next.rsc.errorBoundary");
+var DEFAULT_STREAMING_TIMEOUT_MS = 5e3;
+function buildErrorBoundary(error) {
+  return { [RSC_ERROR_BOUNDARY_SYMBOL]: true, error };
+}
+async function runWithTimeout(promise, timeoutMs) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ value: null, timedOut: true }), timeoutMs);
+  });
+  try {
+    const value = await Promise.race([
+      promise.then((v) => ({ value: v, timedOut: false })),
+      timeout
+    ]);
+    return value;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function collectStream(source, fallback) {
+  const chunks = [];
+  if (typeof fallback !== "undefined" && fallback !== null) {
+    chunks.push(fallback);
+  }
+  try {
+    for await (const chunk of source) {
+      chunks.push(chunk);
+    }
+  } catch (err) {
+    return { chunks, resolved: null, thrown: err };
+  }
+  const resolved = chunks.length > 0 ? chunks[chunks.length - 1] ?? null : null;
+  const fallbackOnly = chunks.length === 1 && fallback !== null && Object.is(chunks[0], fallback);
+  return { chunks, resolved: fallbackOnly ? null : resolved, thrown: void 0 };
+}
+async function* singleChunkSource(component, props) {
+  const result = await component(props);
+  yield result;
+}
+async function setupNextRscEnv(opts = {}) {
+  const timeoutMs = opts.streamingTimeout ?? DEFAULT_STREAMING_TIMEOUT_MS;
+  const fallback = opts.suspenseFallback ?? null;
+  if (timeoutMs <= 0 && (opts.dataSource || opts.component)) {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: null,
+      timedOut: true
+    };
+  }
+  if (typeof opts.injectError !== "undefined") {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: buildErrorBoundary(opts.injectError),
+      timedOut: false
+    };
+  }
+  if (!opts.dataSource && !opts.component) {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: null,
+      timedOut: false
+    };
+  }
+  const source = opts.dataSource ? opts.dataSource : singleChunkSource(opts.component, opts.props ?? {});
+  const { value, timedOut } = await runWithTimeout(collectStream(source, fallback), timeoutMs);
+  if (timedOut || value === null) {
+    return {
+      chunks: fallback !== null ? [fallback] : [],
+      fallback,
+      resolved: null,
+      errorBoundary: null,
+      timedOut: true
+    };
+  }
+  const { chunks, resolved, thrown } = value;
+  if (typeof thrown !== "undefined") {
+    return {
+      chunks,
+      fallback,
+      resolved: null,
+      errorBoundary: buildErrorBoundary(thrown),
+      timedOut: false
+    };
+  }
+  return {
+    chunks,
+    fallback,
+    resolved,
+    errorBoundary: null,
+    timedOut: false
+  };
+}
+
+// src/semantics/types.ts
+var dialect = {
+  "app-router": {
+    "action.form_submitted": "app.server-action.form.submit",
+    "action.revalidate_path": "app.cache.revalidatePath",
+    "action.revalidate_tag": "app.cache.revalidateTag",
+    "action.redirected": "app.navigation.redirect",
+    "ppr.static_shell_rendered": "app.ppr.static-shell",
+    "ppr.dynamic_hole_opened": "app.ppr.dynamic-hole",
+    "ppr.streaming_boundary_flushed": "app.ppr.stream-boundary",
+    "ppr.completed": "app.ppr.complete",
+    "intercept.current_segment": "app.intercept.current",
+    "intercept.parent_segment": "app.intercept.parent",
+    "intercept.root_catchall": "app.intercept.root",
+    "intercept.modal_opened": "app.intercept.modal",
+    "parallel.default_rendered": "app.parallel.default",
+    "parallel.loading_rendered": "app.parallel.loading",
+    "parallel.error_boundary_captured": "app.parallel.error",
+    "parallel.slot_navigated": "app.parallel.navigate"
+  },
+  "pages-router": {
+    "action.form_submitted": "pages.api.form.submit",
+    "action.revalidate_path": "pages.isr.revalidate",
+    "action.revalidate_tag": "pages.cache.tag.noop",
+    "action.redirected": "pages.router.redirect",
+    "ppr.static_shell_rendered": "pages.ssg.shell",
+    "ppr.dynamic_hole_opened": "pages.ssr.dynamic-hole",
+    "ppr.streaming_boundary_flushed": "pages.stream.boundary",
+    "ppr.completed": "pages.render.complete",
+    "intercept.current_segment": "pages.intercept.current",
+    "intercept.parent_segment": "pages.intercept.parent",
+    "intercept.root_catchall": "pages.intercept.root",
+    "intercept.modal_opened": "pages.modal.open",
+    "parallel.default_rendered": "pages.slot.default",
+    "parallel.loading_rendered": "pages.slot.loading",
+    "parallel.error_boundary_captured": "pages.slot.error",
+    "parallel.slot_navigated": "pages.slot.navigate"
+  },
+  "edge-runtime": {
+    "action.form_submitted": "edge.action.form.submit",
+    "action.revalidate_path": "edge.cache.revalidatePath",
+    "action.revalidate_tag": "edge.cache.revalidateTag",
+    "action.redirected": "edge.response.redirect",
+    "ppr.static_shell_rendered": "edge.ppr.static-shell",
+    "ppr.dynamic_hole_opened": "edge.ppr.dynamic-hole",
+    "ppr.streaming_boundary_flushed": "edge.stream.boundary",
+    "ppr.completed": "edge.ppr.complete",
+    "intercept.current_segment": "edge.intercept.current",
+    "intercept.parent_segment": "edge.intercept.parent",
+    "intercept.root_catchall": "edge.intercept.root",
+    "intercept.modal_opened": "edge.modal.open",
+    "parallel.default_rendered": "edge.parallel.default",
+    "parallel.loading_rendered": "edge.parallel.loading",
+    "parallel.error_boundary_captured": "edge.parallel.error",
+    "parallel.slot_navigated": "edge.parallel.navigate"
+  }
+};
+function providerEventName(target, neutral) {
+  return dialect[target][neutral] ?? neutral;
+}
+
+// src/semantics/server-action-advanced.ts
+function startServerActionAdvanced(input) {
+  if (input.actionId.length === 0) {
+    throw new Error("startServerActionAdvanced: actionId must not be empty");
+  }
+  return {
+    target: input.target,
+    actionId: input.actionId,
+    state: "idle",
+    form: {},
+    revalidatedPaths: [],
+    revalidatedTags: [],
+    redirectUrl: null,
+    history: []
+  };
+}
+function submitFormAction(session, form) {
+  if (session.state !== "idle") {
+    throw new Error(`submitFormAction: session is ${session.state}, not idle`);
+  }
+  session.state = "submitted";
+  session.form = { ...form };
+  return emit(session, "action.form_submitted", {
+    fields: Object.keys(form).join(","),
+    fieldCount: Object.keys(form).length
+  });
+}
+function revalidateActionPath(session, path) {
+  if (session.state === "idle") {
+    throw new Error("revalidateActionPath: form action was not submitted");
+  }
+  if (!path.startsWith("/")) {
+    throw new Error("revalidateActionPath: path must start with /");
+  }
+  session.state = "path-revalidated";
+  session.revalidatedPaths.push(path);
+  return emit(session, "action.revalidate_path", { path, count: session.revalidatedPaths.length });
+}
+function revalidateActionTag(session, tag) {
+  if (session.state === "idle") {
+    throw new Error("revalidateActionTag: form action was not submitted");
+  }
+  if (tag.length === 0) {
+    throw new Error("revalidateActionTag: tag must not be empty");
+  }
+  session.state = "tag-revalidated";
+  session.revalidatedTags.push(tag);
+  return emit(session, "action.revalidate_tag", { tag, count: session.revalidatedTags.length });
+}
+function redirectAction(session, url) {
+  if (session.state === "idle") {
+    throw new Error("redirectAction: form action was not submitted");
+  }
+  if (url.length === 0) {
+    throw new Error("redirectAction: url must not be empty");
+  }
+  session.state = "redirected";
+  session.redirectUrl = url;
+  return emit(session, "action.redirected", { url });
+}
+function emit(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, actionId: session.actionId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/partial-prerendering.ts
+function startPartialPrerendering(input) {
+  if (input.routeId.length === 0) {
+    throw new Error("startPartialPrerendering: routeId must not be empty");
+  }
+  return {
+    target: input.target,
+    routeId: input.routeId,
+    state: "idle",
+    shellHtml: null,
+    dynamicHoles: /* @__PURE__ */ new Map(),
+    streamedBoundaries: [],
+    history: []
+  };
+}
+function renderStaticShell(session, html) {
+  if (session.state !== "idle") {
+    throw new Error(`renderStaticShell: session is ${session.state}, not idle`);
+  }
+  if (html.length === 0) {
+    throw new Error("renderStaticShell: html must not be empty");
+  }
+  session.state = "static-shell";
+  session.shellHtml = html;
+  return emit2(session, "ppr.static_shell_rendered", { bytes: html.length });
+}
+function openDynamicHole(session, input) {
+  if (session.shellHtml === null) {
+    throw new Error("openDynamicHole: static shell must be rendered first");
+  }
+  if (input.holeId.length === 0) {
+    throw new Error("openDynamicHole: holeId must not be empty");
+  }
+  session.state = "dynamic-hole";
+  session.dynamicHoles.set(input.holeId, input.fallback);
+  return emit2(session, "ppr.dynamic_hole_opened", {
+    holeId: input.holeId,
+    fallback: input.fallback,
+    holeCount: session.dynamicHoles.size
+  });
+}
+function flushStreamingBoundary(session, input) {
+  if (!session.dynamicHoles.has(input.holeId)) {
+    throw new Error(`flushStreamingBoundary: ${input.holeId} is not an open dynamic hole`);
+  }
+  if (input.html.length === 0) {
+    throw new Error("flushStreamingBoundary: html must not be empty");
+  }
+  session.state = "streaming";
+  session.streamedBoundaries.push(input.holeId);
+  session.dynamicHoles.set(input.holeId, input.html);
+  return emit2(session, "ppr.streaming_boundary_flushed", {
+    holeId: input.holeId,
+    bytes: input.html.length
+  });
+}
+function completePartialPrerendering(session) {
+  if (session.shellHtml === null) {
+    throw new Error("completePartialPrerendering: static shell was not rendered");
+  }
+  session.state = "completed";
+  return emit2(session, "ppr.completed", {
+    holeCount: session.dynamicHoles.size,
+    streamedCount: session.streamedBoundaries.length
+  });
+}
+function emit2(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, routeId: session.routeId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/interception-routes.ts
+function startInterceptionRoutes(input) {
+  if (input.routeId.length === 0) {
+    throw new Error("startInterceptionRoutes: routeId must not be empty");
+  }
+  return {
+    target: input.target,
+    routeId: input.routeId,
+    state: "idle",
+    matches: [],
+    modalRoute: null,
+    history: []
+  };
+}
+function interceptCurrentSegment(session, from, to) {
+  return intercept(session, "(.)", "current", "intercept.current_segment", from, to);
+}
+function interceptParentSegment(session, from, to) {
+  return intercept(session, "(..)", "parent", "intercept.parent_segment", from, to);
+}
+function interceptRootCatchall(session, from, to) {
+  return intercept(session, "(...)", "root", "intercept.root_catchall", from, to);
+}
+function openInterceptedModal(session, modalRoute) {
+  if (modalRoute.length === 0) {
+    throw new Error("openInterceptedModal: modalRoute must not be empty");
+  }
+  if (session.matches.length === 0) {
+    throw new Error("openInterceptedModal: an interception match is required first");
+  }
+  session.state = "modal-open";
+  session.modalRoute = modalRoute;
+  return emit3(session, "intercept.modal_opened", {
+    modalRoute,
+    matchCount: session.matches.length
+  });
+}
+function intercept(session, matcher, state, neutralEvent, from, to) {
+  if (!from.startsWith("/") || !to.startsWith("/")) {
+    throw new Error("intercept: from and to must start with /");
+  }
+  session.state = state;
+  session.matches.push({ matcher, from, to });
+  return emit3(session, neutralEvent, { matcher, from, to });
+}
+function emit3(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, routeId: session.routeId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/parallel-routes-advanced.ts
+function startParallelRoutesAdvanced(input) {
+  if (input.layoutId.length === 0) {
+    throw new Error("startParallelRoutesAdvanced: layoutId must not be empty");
+  }
+  return {
+    target: input.target,
+    layoutId: input.layoutId,
+    state: "idle",
+    slots: /* @__PURE__ */ new Map(),
+    loadingSlots: /* @__PURE__ */ new Set(),
+    errors: [],
+    history: []
+  };
+}
+function renderDefaultSlot(session, slot, html) {
+  assertSlot(slot);
+  session.state = "default-rendered";
+  session.slots.set(slot, html);
+  return emit4(session, "parallel.default_rendered", { slot, html });
+}
+function renderLoadingState(session, slot) {
+  assertSlot(slot);
+  session.state = "loading-rendered";
+  session.loadingSlots.add(slot);
+  return emit4(session, "parallel.loading_rendered", {
+    slot,
+    loadingCount: session.loadingSlots.size
+  });
+}
+function captureParallelError(session, input) {
+  assertSlot(input.slot);
+  const message = typeof input.error === "string" ? input.error : input.error.message;
+  session.state = "error-captured";
+  session.errors.push({ slot: input.slot, message });
+  return emit4(session, "parallel.error_boundary_captured", {
+    slot: input.slot,
+    message,
+    errorCount: session.errors.length
+  });
+}
+function navigateSlot(session, input) {
+  assertSlot(input.slot);
+  if (!input.from.startsWith("/") || !input.to.startsWith("/")) {
+    throw new Error("navigateSlot: from and to must start with /");
+  }
+  session.state = "slot-navigated";
+  session.loadingSlots.delete(input.slot);
+  return emit4(session, "parallel.slot_navigated", input);
+}
+function assertSlot(slot) {
+  if (slot.length === 0) {
+    throw new Error("slot must not be empty");
+  }
+}
+function emit4(session, neutralEvent, metadata) {
+  const step = {
+    neutralEvent,
+    providerEvent: providerEventName(session.target, neutralEvent),
+    state: session.state,
+    amountCents: 0,
+    metadata: { target: session.target, layoutId: session.layoutId, ...metadata }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/fidelity.ts
+var NEXT_AXIS_TO_EVENTS = {
+  "server-action-advanced": [
+    "action.form_submitted",
+    "action.revalidate_path",
+    "action.revalidate_tag",
+    "action.redirected"
+  ],
+  "partial-prerendering": [
+    "ppr.static_shell_rendered",
+    "ppr.dynamic_hole_opened",
+    "ppr.streaming_boundary_flushed",
+    "ppr.completed"
+  ],
+  "interception-routes": [
+    "intercept.current_segment",
+    "intercept.parent_segment",
+    "intercept.root_catchall",
+    "intercept.modal_opened"
+  ],
+  "parallel-routes-advanced": [
+    "parallel.default_rendered",
+    "parallel.loading_rendered",
+    "parallel.error_boundary_captured",
+    "parallel.slot_navigated"
+  ]
+};
+function collectFidelityCoverage(providers = ["app-router", "pages-router", "edge-runtime"]) {
+  const axes = Object.keys(NEXT_AXIS_TO_EVENTS);
+  const rows = [];
+  for (const provider of providers) {
+    for (const axis of axes) {
+      const neutralEvents = NEXT_AXIS_TO_EVENTS[axis];
+      rows.push({
+        provider,
+        axis,
+        neutralEvents,
+        providerEvents: neutralEvents.map((event) => providerEventName(provider, event))
+      });
+    }
+  }
+  return { providers, axes, rows };
+}
+
+// src/real-driver.ts
+var TARGET_KEY_ENV = {
+  "app-router": "NEXT_APP_URL",
+  "pages-router": "NEXT_PAGES_URL",
+  "edge-runtime": "EDGE_RUNTIME_URL"
+};
+function resolveMode(provider, env = process.env) {
+  const rawMode = env.KIWA_MODE?.toLowerCase();
+  if (rawMode !== void 0 && rawMode !== "real" && rawMode !== "mock") {
+    return { provider, mode: "mock", reason: "invalid-mode" };
+  }
+  if (rawMode !== "real") {
+    return { provider, mode: "mock", reason: "default-mock" };
+  }
+  const keyValue = env[TARGET_KEY_ENV[provider]];
+  if (typeof keyValue !== "string" || keyValue.length === 0) {
+    return { provider, mode: "mock", reason: "missing-key" };
+  }
+  return { provider, mode: "real", reason: "kiwa-mode-real" };
+}
+function resolveAllModes(env = process.env) {
+  const providers = ["app-router", "pages-router", "edge-runtime"];
+  return providers.map((provider) => resolveMode(provider, env));
+}
+function assertMode(provider, expected, env = process.env) {
+  const resolved = resolveMode(provider, env);
+  if (resolved.mode !== expected) {
+    throw new Error(
+      `expected ${provider} in ${expected} mode but resolved ${resolved.mode} (${resolved.reason})`
+    );
+  }
+}
 export {
   FORBIDDEN_SYMBOL,
   MIDDLEWARE_ACTION_SYMBOL,
+  NEXT_AXIS_TO_EVENTS,
   NOT_FOUND_SYMBOL,
   PARALLEL_INTERCEPTION_SYMBOL,
   REDIRECT_SYMBOL,
+  RSC_ERROR_BOUNDARY_SYMBOL,
   RSC_REDIRECT_SYMBOL,
+  assertMode,
+  captureParallelError,
+  collectFidelityCoverage,
+  completePartialPrerendering,
   findAll,
+  flushStreamingBoundary,
+  interceptCurrentSegment,
+  interceptParentSegment,
+  interceptRootCatchall,
   invokeMiddleware,
   invokeParallelRoutes,
   invokeServerAction,
   middlewareActions,
+  navigateSlot,
+  openDynamicHole,
+  openInterceptedModal,
+  providerEventName,
+  redirectAction,
+  renderDefaultSlot,
+  renderLoadingState,
   renderServerComponent,
+  renderStaticShell,
+  resolveAllModes,
+  resolveMode,
+  revalidateActionPath,
+  revalidateActionTag,
+  setupNextRscEnv,
+  startInterceptionRoutes,
+  startParallelRoutesAdvanced,
+  startPartialPrerendering,
+  startServerActionAdvanced,
+  submitFormAction,
   textContent
 };
 //# sourceMappingURL=index.js.map