@tai42/studio-sdk 19.2.0 → 19.3.0

package/src/schema-form/visibility.ts

@@ -0,0 +1,47 @@
+/**
+ * The single evaluator for a property's `visibleWhen` predicate — a static,
+ * declarative field-visibility rule (scope B). The renderer (`ObjectFields`) and the
+ * validator both call it so a field shown by the form is exactly the field validated at
+ * submit, and a hidden field is neither rendered nor required. It reads only sibling
+ * values already in the object; it never calls a consumer handler (that is scope A).
+ *
+ * A malformed predicate degrades to VISIBLE: the send-time server validation rejects a
+ * malformed predicate loudly, so one never reaches a well-formed render, and showing a
+ * field is the safe non-hiding default (a hidden-by-accident required field would dead-
+ * end a form).
+ */
+import type { JsonSchema } from './types';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** A value is "empty" for a `notEmpty` test: absent/null, a blank string, an empty array. */
+function isEmptyValue(value: unknown): boolean {
+  if (value === undefined || value === null) return true;
+  if (typeof value === 'string') return value.trim() === '';
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+
+/**
+ * Whether a property carrying `schema.visibleWhen` is visible against the current
+ * `values` of its enclosing object. Absent predicate ⇒ always visible. Exactly one of
+ * `equals`/`in`/`notEmpty` must be present; otherwise the predicate is malformed and the
+ * field stays visible.
+ */
+export function isFieldVisible(schema: JsonSchema, values: Record<string, unknown>): boolean {
+  const predicate: unknown = schema.visibleWhen;
+  if (!isRecord(predicate) || typeof predicate.field !== 'string') return true;
+  const current = values[predicate.field];
+
+  const inList = predicate.in;
+  const hasEquals = 'equals' in predicate;
+  const hasIn = Array.isArray(inList);
+  const hasNotEmpty = predicate.notEmpty === true;
+  if (Number(hasEquals) + Number(hasIn) + Number(hasNotEmpty) !== 1) return true;
+
+  if (hasEquals) return current === predicate.equals;
+  if (hasIn) return (inList as readonly unknown[]).some((candidate) => candidate === current);
+  return !isEmptyValue(current);
+}