@dreamboard-games/ui-sdk 0.0.42 → 0.0.45

package/src/utils/interaction-router.ts

@@ -0,0 +1,200 @@
+import type { InteractionUiStore } from "../context/InteractionDraftContext.js";
+import type { InteractionDescriptor } from "../types/plugin-state.js";
+import {
+  applyInteractionInputDefaults,
+  dependentInputKeys,
+  hasInteractionFieldErrors,
+  inputByKey,
+  interactionArmScope,
+  interactionInputKeys,
+  isInputValueReady,
+  resolveInputDomain,
+  toggleManyValue,
+  validateInteractionInputDomains,
+} from "./interaction-inputs.js";
+
+export interface InteractionDraftMutation {
+  key: string;
+  value: unknown;
+}
+
+export interface InteractionDraftReadiness {
+  values: Record<string, unknown>;
+  missingInputs: readonly string[];
+  readyFrontier: readonly string[];
+  blockedInputs: readonly string[];
+  fieldErrors: Partial<Record<string, readonly string[]>>;
+  ready: boolean;
+}
+
+export interface RoutedInteractionTarget {
+  inputKey: string;
+  value: string;
+  extraInputs?: Record<string, unknown>;
+}
+
+export interface RoutedInteractionTargetResult {
+  params: Record<string, unknown>;
+  readiness: InteractionDraftReadiness;
+}
+
+export function applyInteractionDraftMutation(
+  store: Pick<InteractionUiStore, "getDraft" | "setInput" | "clearInput">,
+  descriptor: InteractionDescriptor,
+  mutations: readonly InteractionDraftMutation[],
+): Record<string, unknown> {
+  const nextDraft: Record<string, unknown> = {
+    ...store.getDraft(descriptor.interactionKey),
+  };
+  const mutatedKeys = new Set(mutations.map((mutation) => mutation.key));
+
+  for (const { key, value } of mutations) {
+    nextDraft[key] = value;
+  }
+
+  for (const { key } of mutations) {
+    for (const dependentKey of dependentInputKeys(descriptor, key)) {
+      if (mutatedKeys.has(dependentKey)) continue;
+      if (shouldClearDependentInput(descriptor, nextDraft, dependentKey)) {
+        delete nextDraft[dependentKey];
+      }
+    }
+  }
+
+  for (const { key, value } of mutations) {
+    store.setInput(descriptor.interactionKey, key, value);
+  }
+  for (const { key } of mutations) {
+    for (const dependentKey of dependentInputKeys(descriptor, key)) {
+      if (mutatedKeys.has(dependentKey)) continue;
+      if (shouldClearDependentInput(descriptor, nextDraft, dependentKey)) {
+        store.clearInput(descriptor.interactionKey, dependentKey);
+      }
+    }
+  }
+
+  return nextDraft;
+}
+
+function shouldClearDependentInput(
+  descriptor: InteractionDescriptor,
+  draft: Readonly<Record<string, unknown>>,
+  dependentKey: string,
+): boolean {
+  const input = inputByKey(descriptor, dependentKey);
+  if (!input) return true;
+  const value = draft[dependentKey];
+  if (!isInputValueReady(resolveInputDomain(input, draft), value)) return true;
+  const errors = validateInteractionInputDomains(descriptor, draft);
+  return (errors[dependentKey]?.length ?? 0) > 0;
+}
+
+export function getInteractionDraftReadiness(
+  descriptor: InteractionDescriptor,
+  draft: Readonly<Record<string, unknown>>,
+): InteractionDraftReadiness {
+  const values = applyInteractionInputDefaults<Record<string, unknown>>(
+    descriptor,
+    draft,
+  ) as Record<string, unknown>;
+  const missingInputs = interactionInputKeys(descriptor).filter((key) => {
+    const input = inputByKey(descriptor, key);
+    const value = values[key];
+    return input
+      ? !isInputValueReady(resolveInputDomain(input, values), value)
+      : value === null || value === undefined;
+  });
+  const missingInputSet = new Set(missingInputs);
+  const readyFrontier = missingInputs.filter((key) => {
+    const input = inputByKey(descriptor, key);
+    if (!input) return true;
+    return (input.domain.dependsOn ?? []).every((dependencyKey) => {
+      if (missingInputSet.has(dependencyKey)) return false;
+      const dependency = inputByKey(descriptor, dependencyKey);
+      if (!dependency) return values[dependencyKey] !== undefined;
+      return isInputValueReady(
+        resolveInputDomain(dependency, values),
+        values[dependencyKey],
+      );
+    });
+  });
+  const fieldErrors = validateInteractionInputDomains(descriptor, values);
+  return {
+    values,
+    missingInputs,
+    readyFrontier,
+    blockedInputs: missingInputs.filter((key) => !readyFrontier.includes(key)),
+    fieldErrors,
+    ready:
+      missingInputs.length === 0 && !hasInteractionFieldErrors(fieldErrors),
+  };
+}
+
+export function routeInteractionTarget(
+  store: Pick<InteractionUiStore, "getDraft" | "setInput" | "clearInput">,
+  descriptor: InteractionDescriptor,
+  target: RoutedInteractionTarget,
+): RoutedInteractionTargetResult {
+  const input = inputByKey(descriptor, target.inputKey);
+  const currentDraft = store.getDraft(descriptor.interactionKey);
+  const selection =
+    input?.domain.type === "target" ? input.domain.selection : undefined;
+  const targetValue =
+    selection?.mode === "many"
+      ? toggleManyValue(currentDraft[target.inputKey], target.value, selection)
+      : target.value;
+  const params = applyInteractionDraftMutation(store, descriptor, [
+    ...Object.entries(target.extraInputs ?? {}).map(([key, value]) => ({
+      key,
+      value,
+    })),
+    { key: target.inputKey, value: targetValue },
+  ]);
+  return {
+    params,
+    readiness: getInteractionDraftReadiness(descriptor, params),
+  };
+}
+
+export function shouldRouteInteractionPending(
+  descriptor: InteractionDescriptor,
+  readiness: Pick<InteractionDraftReadiness, "ready">,
+): boolean {
+  return descriptor.commit.mode !== "autoWhenReady" || !readiness.ready;
+}
+
+export function markInteractionPending(
+  store: Pick<InteractionUiStore, "arm" | "setPendingInteraction">,
+  descriptor: InteractionDescriptor,
+): void {
+  store.arm(interactionArmScope(descriptor), descriptor.interactionKey);
+  store.setPendingInteraction(descriptor.interactionKey);
+}
+
+export function clearInteractionRoute(
+  store: Pick<
+    InteractionUiStore,
+    | "clearInput"
+    | "getArmed"
+    | "arm"
+    | "getPendingInteraction"
+    | "setPendingInteraction"
+  >,
+  descriptor: InteractionDescriptor,
+): void {
+  const armScope = interactionArmScope(descriptor);
+  store.clearInput(descriptor.interactionKey);
+  if (store.getArmed(armScope) === descriptor.interactionKey) {
+    store.arm(armScope, null);
+  }
+  if (store.getPendingInteraction() === descriptor.interactionKey) {
+    store.setPendingInteraction(null);
+  }
+}
+
+export function claimInteractionSubmit(
+  store: Pick<InteractionUiStore, "claimSubmitting">,
+  descriptor: InteractionDescriptor,
+): boolean {
+  return store.claimSubmitting(descriptor.interactionKey);
+}