@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/ui/intelligent-ui/use-ui-queries.js

@@ -6,268 +6,278 @@ const NO_READINGS = {};
 const INPUT_SETTLE_MS = 300;
 /* The reading that holds for these inputs: this view's own read of them, or the frozen first one for the inputs the block starts with. */
 function successfulReading(local, initial, identity, signature, defaultInputs) {
-    if (local?.identity === identity && local.successful?.inputs === signature) {
-        return local.successful.reading;
-    }
-    return signature === defaultInputs && initial?.state === 'fresh' ? initial : undefined;
+  if (local?.identity === identity && local.successful?.inputs === signature) {
+    return local.successful.reading;
+  }
+  return signature === defaultInputs && initial?.state === 'fresh' ? initial : undefined;
 }
 function settleDeadline() {
-    return Date.now() + INPUT_SETTLE_MS;
+  return Date.now() + INPUT_SETTLE_MS;
 }
 function documentVisible() {
-    return document.visibilityState !== 'hidden';
+  return document.visibilityState !== 'hidden';
 }
 export function useUiQueries(block, state, context, element, frozen) {
-    const host = useChatHost();
-    const [readings, setReadings] = useState({});
-    const [busyInput, setBusyInput] = useState(null);
-    const lastRead = useRef({ inputKey: '', at: 0 });
-    const names = Object.keys(block.queries);
-    const inputs = JSON.stringify(uiInputValues(block, state));
-    const identity = JSON.stringify([context.scopeId, context.chatId, context.itemId, block.id, block.revision]);
-    const inputKey = JSON.stringify([identity, inputs]);
-    const reading = busyInput === inputKey;
-    const defaultInputs = useMemo(() => JSON.stringify(uiInputValues(block, new UiState(block))), [block]);
-    const initial = frozen && frozen.revision === block.revision ? frozen.readings : NO_READINGS;
-    const successfulFor = (name, signature) => successfulReading(readings[name], initial[name], identity, signature, defaultInputs);
-    const readsFor = (values) => {
-        const signature = JSON.stringify(values);
-        const reads = {};
-        for (const name of names) {
-            const local = readings[name];
-            const successful = successfulFor(name, signature);
-            if (!successful?.readId || (local?.identity === identity && local.reading.state === 'refused')) {
-                return null;
-            }
-            reads[name] = successful.readId;
-        }
-        return reads;
-    };
-    const reads = readsFor(JSON.parse(inputs));
-    const ready = reads !== null;
-    const query = host.intelligentUi?.query;
-    const subscribe = host.intelligentUi?.subscribe;
-    useEffect(() => {
-        const scope = state.scope();
-        for (const name of Object.keys(block.queries)) {
-            const successful = successfulReading(readings[name], initial[name], identity, inputs, defaultInputs);
-            if (successful && JSON.stringify(scope[name]) !== JSON.stringify(successful.value)) {
-                state.setQuery(name, successful.value, block);
-            }
-        }
-    }, [state, block, readings, identity, inputs, defaultInputs, initial]);
-    useEffect(() => {
-        if (!query ||
-            !element ||
-            !block.complete ||
-            block.catalogVersion !== UI_CATALOG_VERSION ||
-            !block.revision ||
-            !Object.keys(block.queries).length ||
-            context.phase !== 'final') {
+  const host = useChatHost();
+  const [readings, setReadings] = useState({});
+  const [busyInput, setBusyInput] = useState(null);
+  const lastRead = useRef({
+    inputKey: '',
+    at: 0
+  });
+  const names = Object.keys(block.queries);
+  const inputs = JSON.stringify(uiInputValues(block, state));
+  const identity = JSON.stringify([context.scopeId, context.chatId, context.itemId, block.id, block.revision]);
+  const inputKey = JSON.stringify([identity, inputs]);
+  const reading = busyInput === inputKey;
+  const defaultInputs = useMemo(() => JSON.stringify(uiInputValues(block, new UiState(block))), [block]);
+  const initial = frozen && frozen.revision === block.revision ? frozen.readings : NO_READINGS;
+  const successfulFor = (name, signature) => successfulReading(readings[name], initial[name], identity, signature, defaultInputs);
+  const readsFor = values => {
+    const signature_0 = JSON.stringify(values);
+    const reads = {};
+    for (const name_0 of names) {
+      const local = readings[name_0];
+      const successful = successfulFor(name_0, signature_0);
+      if (!successful?.readId || local?.identity === identity && local.reading.state === 'refused') {
+        return null;
+      }
+      reads[name_0] = successful.readId;
+    }
+    return reads;
+  };
+  const reads_0 = readsFor(JSON.parse(inputs));
+  const ready = reads_0 !== null;
+  const query = host.intelligentUi?.query;
+  const subscribe = host.intelligentUi?.subscribe;
+  useEffect(() => {
+    const scope = state.scope();
+    for (const name_1 of Object.keys(block.queries)) {
+      const successful_0 = successfulReading(readings[name_1], initial[name_1], identity, inputs, defaultInputs);
+      if (successful_0 && JSON.stringify(scope[name_1]) !== JSON.stringify(successful_0.value)) {
+        state.setQuery(name_1, successful_0.value, block);
+      }
+    }
+  }, [state, block, readings, identity, inputs, defaultInputs, initial]);
+  useEffect(() => {
+    if (!query || !element || !block.complete || block.catalogVersion !== UI_CATALOG_VERSION || !block.revision || !Object.keys(block.queries).length || context.phase !== 'final') {
+      return;
+    }
+    let stopped = false;
+    let visible = typeof IntersectionObserver === 'undefined';
+    let busy = false;
+    let timer = null;
+    // The first read of this block reads at once; a changed input waits until it rests.
+    const changed = lastRead.current.inputKey !== '' && lastRead.current.inputKey !== inputKey;
+    const settledAt = changed ? settleDeadline() : 0;
+    const refresh = async () => {
+      if (stopped || !visible || !documentVisible() || busy) {
+        return;
+      }
+      const wait = Math.max(settledAt - Date.now(), lastRead.current.inputKey === inputKey ? UI_HOST_LIMITS.refreshMilliseconds - (Date.now() - lastRead.current.at) : 0);
+      if (wait > 0) {
+        if (timer === null) {
+          if (!visible || !documentVisible()) {
             return;
-        }
-        let stopped = false;
-        let visible = typeof IntersectionObserver === 'undefined';
-        let busy = false;
-        let timer = null;
-        // The first read of this block reads at once; a changed input waits until it rests.
-        const changed = lastRead.current.inputKey !== '' && lastRead.current.inputKey !== inputKey;
-        const settledAt = changed ? settleDeadline() : 0;
-        const refresh = async () => {
-            if (stopped || !visible || !documentVisible() || busy) {
-                return;
-            }
-            const wait = Math.max(settledAt - Date.now(), lastRead.current.inputKey === inputKey ? UI_HOST_LIMITS.refreshMilliseconds - (Date.now() - lastRead.current.at) : 0);
-            if (wait > 0) {
-                if (timer === null) {
-                    if (!visible || !documentVisible()) {
-                        return;
-                    }
-                    timer = setTimeout(() => {
-                        timer = null;
-                        void refresh();
-                    }, wait);
-                }
-                return;
-            }
-            busy = true;
-            lastRead.current = { inputKey, at: Date.now() };
-            setBusyInput(inputKey);
-            for (const name of Object.keys(block.queries).slice(0, UI_HOST_LIMITS.queries)) {
-                if (!visible || !documentVisible()) {
-                    break;
-                }
-                try {
-                    const reading = await query(context.scopeId, {
-                        chatId: context.chatId,
-                        itemId: context.itemId,
-                        blockId: block.id,
-                        revision: block.revision,
-                        query: name,
-                        values: JSON.parse(inputs)
-                    });
-                    if (stopped) {
-                        return;
-                    }
-                    if (reading.state === 'fresh') {
-                        state.setQuery(name, reading.value, block);
-                    }
-                    setReadings((previous) => ({
-                        ...previous,
-                        [name]: {
-                            identity,
-                            reading,
-                            successful: reading.state === 'fresh' ? { inputs, reading } : previous[name]?.identity === identity ? previous[name].successful : undefined
-                        }
-                    }));
-                }
-                catch (error) {
-                    if (stopped) {
-                        return;
-                    }
-                    setReadings((previous) => ({
-                        ...previous,
-                        [name]: {
-                            identity,
-                            reading: { state: 'failed', readAt: Date.now(), code: 'unreadable', reason: error instanceof Error ? error.message : undefined },
-                            successful: previous[name]?.identity === identity ? previous[name].successful : undefined
-                        }
-                    }));
-                }
-            }
-            busy = false;
-            if (stopped) {
-                return;
-            }
-            setBusyInput(null);
-            timer = setTimeout(() => {
-                timer = null;
-                void refresh();
-            }, UI_HOST_LIMITS.refreshMilliseconds);
-        };
-        const observer = typeof IntersectionObserver === 'undefined'
-            ? null
-            : new IntersectionObserver((entries) => {
-                visible = entries.some((entry) => entry.isIntersecting);
-                if (visible) {
-                    void refresh();
-                }
-                else if (timer !== null) {
-                    clearTimeout(timer);
-                    timer = null;
-                }
-            });
-        if (element) {
-            observer?.observe(element);
-        }
-        const focus = () => {
+          }
+          timer = setTimeout(() => {
+            timer = null;
             void refresh();
-        };
-        document.addEventListener('visibilitychange', focus);
-        const unsubscribe = subscribe?.(context.scopeId, context.chatId, focus);
-        void refresh();
-        return () => {
-            stopped = true;
-            // A read cut short by this cleanup never reaches its own reset, which would leave the choices closed.
-            setBusyInput((current) => (current === inputKey ? null : current));
-            observer?.disconnect();
-            unsubscribe?.();
-            document.removeEventListener('visibilitychange', focus);
-            if (timer !== null) {
-                clearTimeout(timer);
-            }
-        };
-    }, [block, state, context.scopeId, context.chatId, context.itemId, context.phase, inputs, query, subscribe, element, identity, inputKey]);
-    const currentReadings = Object.fromEntries(names.flatMap((name) => {
-        const local = readings[name];
-        const reading = local?.identity === identity ? local.reading : initial[name];
-        return reading ? [[name, reading]] : [];
-    }));
-    const failed = Object.entries(currentReadings).find(([, value]) => value.state !== 'fresh');
-    const live = names.length
-        ? {
-            state: reading || (!ready && !failed) ? 'reading' : (failed?.[1].state ?? 'fresh'),
-            sources: names.map((name) => block.queries[name].source),
-            readAt: Object.values(currentReadings)
-                .filter((reading) => reading.state === 'fresh')
-                .reduce((at, value) => (at === null ? value.readAt : Math.min(at, value.readAt)), null),
-            source: failed ? block.queries[failed[0]]?.source : undefined,
-            reason: failed?.[1].reason,
-            code: failed?.[1].code
+          }, wait);
         }
-        : undefined;
-    return { live, reads: reads ?? {}, reading, ready, readsFor, currentReadings };
-}
-export function useUiLiveValues(block, nodes, readings) {
-    const [committed, setCommitted] = useState({
-        token: '',
-        values: new Map(),
-        previous: new Map()
-    });
-    const dependencies = new Map();
-    const names = new Set(Object.keys(block.queries));
-    const references = (value, into) => {
-        if (!value || typeof value !== 'object') {
-            return;
+        return;
+      }
+      busy = true;
+      lastRead.current = {
+        inputKey,
+        at: Date.now()
+      };
+      setBusyInput(inputKey);
+      for (const name_2 of Object.keys(block.queries).slice(0, UI_HOST_LIMITS.queries)) {
+        if (!visible || !documentVisible()) {
+          break;
         }
-        const expression = value;
-        if (expression.kind === 'reference' && names.has(String(expression.name))) {
-            into.add(String(expression.name));
-        }
-        for (const child of Object.values(expression)) {
-            if (Array.isArray(child)) {
-                child.forEach((item) => references(item, into));
+        try {
+          const reading_0 = await query(context.scopeId, {
+            chatId: context.chatId,
+            itemId: context.itemId,
+            blockId: block.id,
+            revision: block.revision,
+            query: name_2,
+            values: JSON.parse(inputs)
+          });
+          if (stopped) {
+            return;
+          }
+          if (reading_0.state === 'fresh') {
+            state.setQuery(name_2, reading_0.value, block);
+          }
+          setReadings(previous_0 => ({
+            ...previous_0,
+            [name_2]: {
+              identity,
+              reading: reading_0,
+              successful: reading_0.state === 'fresh' ? {
+                inputs,
+                reading: reading_0
+              } : previous_0[name_2]?.identity === identity ? previous_0[name_2].successful : undefined
             }
-            else if (typeof child === 'object') {
-                references(child, into);
+          }));
+        } catch (error) {
+          if (stopped) {
+            return;
+          }
+          setReadings(previous => ({
+            ...previous,
+            [name_2]: {
+              identity,
+              reading: {
+                state: 'failed',
+                readAt: Date.now(),
+                code: 'unreadable',
+                reason: error instanceof Error ? error.message : undefined
+              },
+              successful: previous[name_2]?.identity === identity ? previous[name_2].successful : undefined
             }
+          }));
         }
+      }
+      busy = false;
+      if (stopped) {
+        return;
+      }
+      setBusyInput(null);
+      timer = setTimeout(() => {
+        timer = null;
+        void refresh();
+      }, UI_HOST_LIMITS.refreshMilliseconds);
     };
-    const written = (nodes, inherited = new Set()) => {
-        for (const node of nodes) {
-            const related = new Set(inherited);
-            references(node.expressions, related);
-            dependencies.set(node.id, related);
-            written(node.children, node.type === 'Each' ? related : inherited);
-        }
+    const observer = typeof IntersectionObserver === 'undefined' ? null : new IntersectionObserver(entries => {
+      visible = entries.some(entry => entry.isIntersecting);
+      if (visible) {
+        void refresh();
+      } else if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    });
+    if (element) {
+      observer?.observe(element);
+    }
+    const focus = () => {
+      void refresh();
     };
-    written(block.nodes);
-    const values = new Map();
-    const sources = new Map();
-    const collect = (nodes) => {
-        for (const node of nodes) {
-            const related = dependencies.get(node.sourceId ?? node.id);
-            if (related?.size && !node.error) {
-                values.set(node.id, node.props);
-                sources.set(node.id, related);
-            }
-            collect(node.children);
-        }
+    document.addEventListener('visibilitychange', focus);
+    const unsubscribe = subscribe?.(context.scopeId, context.chatId, focus);
+    void refresh();
+    return () => {
+      stopped = true;
+      // A read cut short by this cleanup never reaches its own reset, which would leave the choices closed.
+      setBusyInput(current => current === inputKey ? null : current);
+      observer?.disconnect();
+      unsubscribe?.();
+      document.removeEventListener('visibilitychange', focus);
+      if (timer !== null) {
+        clearTimeout(timer);
+      }
     };
-    collect(nodes);
-    const token = JSON.stringify([block.revision, Object.entries(readings).map(([name, reading]) => [name, reading.state, reading.readId, reading.readAt])]);
-    const previous = committed.token === token ? committed.previous : committed.values;
-    if (committed.token !== token) {
-        setCommitted({ token, values, previous });
+  }, [block, state, context.scopeId, context.chatId, context.itemId, context.phase, inputs, query, subscribe, element, identity, inputKey]);
+  const currentReadings = Object.fromEntries(names.flatMap(name_3 => {
+    const local_0 = readings[name_3];
+    const reading_1 = local_0?.identity === identity ? local_0.reading : initial[name_3];
+    return reading_1 ? [[name_3, reading_1]] : [];
+  }));
+  const failed = Object.entries(currentReadings).find(([, value]) => value.state !== 'fresh');
+  const live = names.length ? {
+    state: reading || !ready && !failed ? 'reading' : failed?.[1].state ?? 'fresh',
+    sources: names.map(name_4 => block.queries[name_4].source),
+    readAt: Object.values(currentReadings).filter(reading_2 => reading_2.state === 'fresh').reduce((at, value_0) => at === null ? value_0.readAt : Math.min(at, value_0.readAt), null),
+    source: failed ? block.queries[failed[0]]?.source : undefined,
+    reason: failed?.[1].reason,
+    code: failed?.[1].code
+  } : undefined;
+  return {
+    live,
+    reads: reads_0 ?? {},
+    reading,
+    ready,
+    readsFor,
+    currentReadings
+  };
+}
+export function useUiLiveValues(block, nodes, readings) {
+  const [committed, setCommitted] = useState({
+    token: '',
+    values: new Map(),
+    previous: new Map()
+  });
+  const dependencies = new Map();
+  const names = new Set(Object.keys(block.queries));
+  const references = (value, into) => {
+    if (!value || typeof value !== 'object') {
+      return;
     }
-    if (!names.size) {
-        return undefined;
+    const expression = value;
+    if (expression.kind === 'reference' && names.has(String(expression.name))) {
+      into.add(String(expression.name));
     }
-    return (id, prop, path) => {
-        const related = sources.get(id);
-        if (!related) {
-            return undefined;
-        }
-        const get = (props) => {
-            const value = props?.[prop];
-            return path && Array.isArray(value) ? value[path[0]]?.[path[1]] : value;
-        };
-        const before = get(previous.get(id));
-        const value = get(values.get(id));
-        return {
-            previous: before,
-            changed: before !== undefined && JSON.stringify(before) !== JSON.stringify(value),
-            stale: [...related].some((name) => readings[name]?.state === 'failed' || readings[name]?.state === 'refused')
-        };
+    for (const child of Object.values(expression)) {
+      if (Array.isArray(child)) {
+        child.forEach(item => references(item, into));
+      } else if (typeof child === 'object') {
+        references(child, into);
+      }
+    }
+  };
+  const written = (nodes_0, inherited = new Set()) => {
+    for (const node of nodes_0) {
+      const related = new Set(inherited);
+      references(node.expressions, related);
+      dependencies.set(node.id, related);
+      written(node.children, node.type === 'Each' ? related : inherited);
+    }
+  };
+  written(block.nodes);
+  const values = new Map();
+  const sources = new Map();
+  const collect = nodes_1 => {
+    for (const node_0 of nodes_1) {
+      const related_0 = dependencies.get(node_0.sourceId ?? node_0.id);
+      if (related_0?.size && !node_0.error) {
+        values.set(node_0.id, node_0.props);
+        sources.set(node_0.id, related_0);
+      }
+      collect(node_0.children);
+    }
+  };
+  collect(nodes);
+  const token = JSON.stringify([block.revision, Object.entries(readings).map(([name, reading]) => [name, reading.state, reading.readId, reading.readAt])]);
+  const previous = committed.token === token ? committed.previous : committed.values;
+  if (committed.token !== token) {
+    setCommitted({
+      token,
+      values,
+      previous
+    });
+  }
+  if (!names.size) {
+    return undefined;
+  }
+  return (id, prop, path) => {
+    const related_1 = sources.get(id);
+    if (!related_1) {
+      return undefined;
+    }
+    const get = props => {
+      const value_0 = props?.[prop];
+      return path && Array.isArray(value_0) ? value_0[path[0]]?.[path[1]] : value_0;
     };
-}
+    const before = get(previous.get(id));
+    const value_1 = get(values.get(id));
+    return {
+      previous: before,
+      changed: before !== undefined && JSON.stringify(before) !== JSON.stringify(value_1),
+      stale: [...related_1].some(name_0 => readings[name_0]?.state === 'failed' || readings[name_0]?.state === 'refused')
+    };
+  };
+}