@richardmcquiston01/dashboard-widgets-toolkit 0.15.0 → 0.17.0

package/dist/react.js

@@ -828,6 +828,14 @@ var DEFAULT_LABELS = {
   menuMoveLater: "Move later",
   menuHide: "Hide",
   menuOptions: "Options\u2026",
+  menuDuplicate: "Duplicate",
+  duplicate: (title) => `Duplicate ${title}`,
+  duplicateBlocked: (title, reason) => `Duplicate ${title} (unavailable: ${reason})`,
+  duplicated: (title) => `Duplicated ${title}`,
+  optionsDelete: "Delete this widget",
+  confirmDelete: "Delete this widget? Its settings are lost.",
+  deleted: (title) => `Deleted ${title}`,
+  suggestedViewTitle: (title, viewLabel) => `${title} ${viewLabel}`,
   optionsFor: (title) => `Options for ${title}`,
   optionsTitleField: "Title",
   titleInUse: "Another widget already uses this title.",
@@ -1937,13 +1945,15 @@ var NOT_LOCKED = Object.freeze({
   move: false,
   hide: false,
   minimize: false,
-  options: false
+  options: false,
+  clone: false
 });
 var FULLY_LOCKED = Object.freeze({
   move: true,
   hide: true,
   minimize: true,
-  options: true
+  options: true,
+  clone: true
 });
 function resolveWidgetLock(definition) {
   const setting = definition.locked;
@@ -1953,7 +1963,8 @@ function resolveWidgetLock(definition) {
     move: setting.move === true,
     hide: setting.hide === true,
     minimize: setting.minimize === true,
-    options: setting.options === true
+    options: setting.options === true,
+    clone: setting.clone === true
   };
 }
 function sortDefinitions(definitions) {
@@ -2055,6 +2066,9 @@ function viewChoices(item) {
     }))
   ];
 }
+function isProviderView(view) {
+  return view.convert === void 0;
+}
 function isKnownView(item, key) {
   return key !== void 0 && (key === BASE_VIEW_KEY || findView(item, key) !== void 0);
 }
@@ -2064,6 +2078,14 @@ function effectiveViewKey(item, chosen) {
   if (isKnownView(item, item.defaultView)) return item.defaultView;
   return BASE_VIEW_KEY;
 }
+function loadViewKey(item, chosen) {
+  const key = effectiveViewKey(item, chosen);
+  const view = findView(item, key);
+  return view !== void 0 && isProviderView(view) ? key : BASE_VIEW_KEY;
+}
+function loadViewKind(item, chosen) {
+  return findView(item, loadViewKey(item, chosen))?.kind ?? item.kind;
+}
 function cellValue2(cell) {
   const value = cell?.value;
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -2198,6 +2220,11 @@ function convertView(widgetKey, view, data, options = {}) {
     where: `Widget ${JSON.stringify(widgetKey)} view ${JSON.stringify(view.key)}`,
     ...options.locale === void 0 ? {} : { locale: options.locale }
   };
+  if (conversion === void 0) {
+    return err(
+      `${context.where}: the provider supplies this view, so there is nothing to convert.`
+    );
+  }
   const expected = VIEW_CONVERSIONS[conversion.type]?.from;
   if (expected === void 0) {
     return err(
@@ -2225,14 +2252,29 @@ function convertView(widgetKey, view, data, options = {}) {
 function applyView(widget, chosen, options = {}) {
   const key = effectiveViewKey(widget.definition, chosen);
   const view = findView(widget.definition, key);
-  if (view === void 0) return widget;
+  const wanted = loadViewKey(widget.definition, chosen);
+  const loaded = widget.status === "ok" ? widget.view ?? BASE_VIEW_KEY : void 0;
+  const mismatched = loaded !== void 0 && loaded !== wanted;
+  if (view === void 0) {
+    return mismatched ? {
+      definition: widget.definition,
+      status: "loading",
+      ...widget.options === void 0 ? {} : { options: widget.options }
+    } : widget;
+  }
   const definition = {
     ...widget.definition,
     kind: view.kind
   };
-  if (widget.status === "loading") return { ...widget, definition };
-  if (widget.status === "empty") return { ...widget, definition };
-  if (widget.status === "error") return { ...widget, definition };
+  if (widget.status !== "ok") return { ...widget, definition };
+  if (mismatched) {
+    return {
+      definition,
+      status: "loading",
+      ...widget.options === void 0 ? {} : { options: widget.options }
+    };
+  }
+  if (isProviderView(view)) return { ...widget, definition };
   const converted = convertView(
     widget.definition.key,
     view,
@@ -2403,6 +2445,62 @@ function isTitleInUse(definitions, layout, key, title) {
   );
 }
 
+// src/core/clones.ts
+function cloneNumber(key) {
+  const match = /#(\d+)$/.exec(key);
+  return match === null ? void 0 : Number(match[1]);
+}
+function cleanClones(definitions, clones, options = {}) {
+  if (clones === void 0) return void 0;
+  const byKey = new Map(definitions.map((d) => [d.key, d]));
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const clone of clones) {
+    if (seen.has(clone.key)) continue;
+    const original = byKey.get(clone.from);
+    if (original === void 0 || original.sourceKey !== void 0) continue;
+    const existing = byKey.get(clone.key);
+    if (existing !== void 0 && existing.sourceKey !== clone.from) continue;
+    if (options.overrideLocks !== true && resolveWidgetLock(original).clone) {
+      continue;
+    }
+    seen.add(clone.key);
+    kept.push(clone);
+  }
+  if (kept.length === 0) return void 0;
+  return kept.length === clones.length && kept.every((c, i) => c === clones[i]) ? clones : kept;
+}
+function defaultCloneTitle(original, clone, index) {
+  const base = original.title ?? original.key;
+  const suffix = ` (#${cloneNumber(clone.key) ?? index + 1})`;
+  return `${base.slice(0, MAX_WIDGET_TITLE_LENGTH - suffix.length)}${suffix}`;
+}
+function withClones(definitions, layout, options = {}) {
+  const valid = cleanClones(
+    definitions,
+    layout.clones,
+    options
+  );
+  if (valid === void 0) return definitions;
+  const present = new Set(definitions.map((d) => d.key));
+  const toAdd = valid.filter((c) => !present.has(c.key));
+  if (toAdd.length === 0) return definitions;
+  const out = [];
+  for (const definition of definitions) {
+    out.push(definition);
+    toAdd.forEach((clone, index) => {
+      if (clone.from !== definition.key) return;
+      const copy = { ...definition };
+      copy.key = clone.key;
+      copy.sourceKey = definition.key;
+      copy.title = defaultCloneTitle(definition, clone, index);
+      delete copy.locked;
+      out.push(copy);
+    });
+  }
+  return out;
+}
+
 // src/core/layout.ts
 var MAX_PAGE_TITLE_LENGTH = 30;
 var MAX_PARSED_PAGES = 50;
@@ -2880,6 +2978,114 @@ function moveWidgetToPage(definitions, layout, widgetKey, targetKey, options = {
   }
   return ok(moved);
 }
+
+// src/core/duplicate.ts
+function canDuplicate(definitions, key, options = {}) {
+  const definition = definitions.find(
+    (d) => d.key === key
+  );
+  if (definition === void 0) return false;
+  if (options.overrideLocks === true) return true;
+  const sourceKey = definition.sourceKey ?? definition.key;
+  const original = definitions.find(
+    (d) => d.key === sourceKey
+  );
+  return original !== void 0 && !resolveWidgetLock(original).clone;
+}
+function nextCloneKey(definitions, layout, fromKey) {
+  const taken = /* @__PURE__ */ new Set([
+    ...definitions.map((d) => d.key),
+    ...(layout.clones ?? []).map((c) => c.key)
+  ]);
+  let highest = 0;
+  for (const clone of layout.clones ?? []) {
+    if (clone.from === fromKey) {
+      highest = Math.max(highest, cloneNumber(clone.key) ?? 0);
+    }
+  }
+  let n = highest + 1;
+  while (taken.has(`${fromKey}#${n}`)) n += 1;
+  return `${fromKey}#${n}`;
+}
+function duplicateWidget(definitions, layout, key, options = {}) {
+  const widget = definitions.find((d) => d.key === key);
+  if (widget === void 0) {
+    return err(`Widget ${JSON.stringify(key)} isn't on this dashboard.`);
+  }
+  const originalKey = widget.sourceKey ?? widget.key;
+  if (!canDuplicate(definitions, key, options)) {
+    return err(
+      `Widget ${JSON.stringify(originalKey)} is locked against duplicating.`
+    );
+  }
+  const cloneKey = nextCloneKey(definitions, layout, originalKey);
+  const copiedSettings = (() => {
+    const mine = layout.settings?.[key];
+    if (mine === void 0) return void 0;
+    const { title: _title, ...rest } = mine;
+    return Object.keys(rest).length === 0 ? void 0 : rest;
+  })();
+  const settings = copiedSettings === void 0 ? layout.settings : { ...layout.settings, [cloneKey]: copiedSettings };
+  let next = {
+    ...layout,
+    clones: [...layout.clones ?? [], { key: cloneKey, from: originalKey }],
+    ...settings === void 0 ? {} : { settings }
+  };
+  const all = withClones(definitions, next, options);
+  const assigned = assignPages(all, next);
+  const pageKey = [...assigned].find(
+    ([, widgets]) => widgets.some((w) => w.key === key)
+  )?.[0];
+  if (pageKey !== void 0) {
+    const view = pageLayout(next, pageKey);
+    const onPage = assigned.get(pageKey) ?? [];
+    if (view !== void 0) {
+      const shown = visibleWidgets(onPage, view).filter((d) => !resolveWidgetLock(d).move && d.key !== cloneKey).map((d) => d.key);
+      const at = shown.indexOf(key);
+      const order = at === -1 ? [...shown, cloneKey] : [...shown.slice(0, at + 1), cloneKey, ...shown.slice(at + 1)];
+      next = withPageLayout(next, pageKey, { ...view, order });
+    }
+  }
+  if (hasPages(next) && pageKey !== void 0) {
+    const effective = effectiveDefinitions(all, next, options);
+    const room = pageRoom(effective, next, pageKey, options);
+    if (room !== void 0 && room.rowsUsed > room.maxRows) {
+      const page = next.pages?.find(
+        (p) => p.key === pageKey
+      );
+      const width = effective.find(
+        (d) => d.key === cloneKey
+      )?.width;
+      return err(
+        `Page "${page?.title ?? pageKey}" has no room for a widget${width === void 0 ? "" : ` ${width} wide`} (it holds ${room.maxRows} rows).`
+      );
+    }
+  }
+  return ok({ layout: next, key: cloneKey });
+}
+function deleteClone(layout, key) {
+  if (layout.clones?.some((clone) => clone.key === key) !== true) return layout;
+  const without2 = (keys) => keys.includes(key) ? keys.filter((k) => k !== key) : keys;
+  const { clones, settings, ...rest } = layout;
+  const remaining = (clones ?? []).filter((c) => c.key !== key);
+  const { [key]: _gone, ...otherSettings } = settings ?? {};
+  return {
+    ...rest,
+    order: without2(layout.order),
+    hidden: without2(layout.hidden),
+    minimized: without2(layout.minimized),
+    ...layout.pages === void 0 ? {} : {
+      pages: layout.pages.map((page) => ({
+        ...page,
+        order: without2(page.order),
+        hidden: without2(page.hidden),
+        minimized: without2(page.minimized)
+      }))
+    },
+    ...Object.keys(otherSettings).length === 0 ? {} : { settings: otherSettings },
+    ...remaining.length === 0 ? {} : { clones: remaining }
+  };
+}
 function InlineConfirm({
   message,
   onAnswer
@@ -3130,6 +3336,8 @@ function WidgetOptionsDialog({
   settings,
   baseline,
   isTitleInUse: isTitleInUse2,
+  sourceTitle,
+  onDelete,
   onApply,
   onClose
 }) {
@@ -3142,6 +3350,7 @@ function WidgetOptionsDialog({
   const [confirming, setConfirming] = useState(
     void 0
   );
+  const autoTitle = useRef(void 0);
   useEffect(() => {
     const dialog = dialogRef.current;
     if (dialog === null) return void 0;
@@ -3184,6 +3393,9 @@ function WidgetOptionsDialog({
     } else if (which === "reset") {
       onApply(EMPTY_PATCH);
       onClose();
+    } else if (which === "delete") {
+      onDelete?.();
+      onClose();
     } else if (baseline !== void 0) {
       onApply(patchFrom(definition, draftFrom(baseline.settings)));
       onClose();
@@ -3199,7 +3411,8 @@ function WidgetOptionsDialog({
     apply: labels.confirmApply,
     discard: labels.confirmDiscard,
     reset: labels.confirmResetOptions,
-    revert: labels.confirmRevertOptions
+    revert: labels.confirmRevertOptions,
+    delete: labels.confirmDelete
   };
   const widths = [];
   for (let width = range.min; width <= range.max; width += 1)
@@ -3296,7 +3509,32 @@ function WidgetOptionsDialog({
                   value: effectiveViewKey(definition, draft.view),
                   onChange: (event) => {
                     const value = event.target.value;
-                    setDraft((current) => ({ ...current, view: value }));
+                    setDraft((current) => {
+                      const next = { ...current, view: value };
+                      if (sourceTitle === void 0 || current.title.trim() !== "" && current.title !== autoTitle.current) {
+                        return next;
+                      }
+                      const label = views.find(
+                        (view) => view.key === value
+                      )?.label;
+                      const startView = effectiveViewKey(
+                        definition,
+                        settings?.view
+                      );
+                      if (label === void 0 || value === startView) {
+                        autoTitle.current = void 0;
+                        return { ...next, title: "" };
+                      }
+                      let suggestion = labels.suggestedViewTitle(
+                        sourceTitle,
+                        label
+                      );
+                      for (let n = 2; isTitleInUse2?.(suggestion) === true && n < 50; n += 1) {
+                        suggestion = `${labels.suggestedViewTitle(sourceTitle, label)} (#${n})`;
+                      }
+                      autoTitle.current = suggestion;
+                      return { ...next, title: suggestion };
+                    });
                   },
                   children: views.map((view) => /* @__PURE__ */ jsx("option", { value: view.key, children: view.key === effectiveViewKey(definition, void 0) ? labels.viewDefault(view.label) : view.label }, view.key))
                 }
@@ -3353,6 +3591,15 @@ function WidgetOptionsDialog({
                   onClick: () => setConfirming("revert"),
                   children: labels.revertToBeforeEditing
                 }
+              ),
+              onDelete !== void 0 && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: slot("button", "dwt-button"),
+                  onClick: () => setConfirming("delete"),
+                  children: labels.optionsDelete
+                }
               )
             ] }) : /* @__PURE__ */ jsx(
               InlineConfirm,
@@ -4357,6 +4604,29 @@ function DashboardInner({
     setPageError(void 0);
     change(withPageLayout(layout, activeKey, next));
   }
+  function duplicateItems(definition, key, title) {
+    const sources = [...authorDefinitions.values()];
+    if (!canDuplicate(sources, key, { overrideLocks })) return [];
+    const trial = duplicateWidget(sources, layout, key, {
+      overrideLocks,
+      ...roomOptions
+    });
+    return [
+      {
+        kind: "action",
+        key: "duplicate",
+        label: labels.menuDuplicate,
+        ariaLabel: trial.ok ? labels.duplicate(title) : labels.duplicateBlocked(title, trial.error),
+        disabled: !trial.ok,
+        onSelect: () => {
+          if (!trial.ok) return;
+          change(trial.value.layout);
+          setOptionsKey(trial.value.key);
+          setAnnouncement(labels.duplicated(title));
+        }
+      }
+    ];
+  }
   function selectPage(pageKey) {
     const index = pages.findIndex((page) => page.key === pageKey);
     if (index === -1) return;
@@ -4486,10 +4756,16 @@ function DashboardInner({
         definitions,
         defaultLayout ?? EMPTY_LAYOUT
       );
-      const { settings: _defaultSettings, ...arrangement } = arranged;
-      change(
-        layout.settings === void 0 ? arrangement : { ...arrangement, settings: layout.settings }
-      );
+      const {
+        settings: _defaultSettings,
+        clones: _defaultClones,
+        ...arrangement
+      } = arranged;
+      change({
+        ...arrangement,
+        ...layout.settings === void 0 ? {} : { settings: layout.settings },
+        ...layout.clones === void 0 ? {} : { clones: layout.clones }
+      });
     } else if (yes && which === "revert" && snapshot !== void 0) {
       change(snapshot);
     }
@@ -4795,6 +5071,7 @@ function DashboardInner({
                           onSelect: () => setOptionsKey(key)
                         }
                       ],
+                      ...duplicateItems(definition, key, title),
                       ...pageTargets,
                       ...lock.hide ? [] : [
                         {
@@ -4889,6 +5166,21 @@ function DashboardInner({
             definition: authorDefinitions.get(optionsKey),
             settings: layout.settings?.[optionsKey],
             ...snapshot === void 0 ? {} : { baseline: { settings: snapshot.settings?.[optionsKey] } },
+            ...authorDefinitions.get(optionsKey)?.sourceKey === void 0 ? {} : {
+              sourceTitle: effectiveWidgets.find(
+                (w) => w.definition.key === authorDefinitions.get(optionsKey)?.sourceKey
+              )?.definition.title ?? authorDefinitions.get(optionsKey)?.sourceKey ?? "",
+              onDelete: () => {
+                change(deleteClone(layout, optionsKey));
+                setAnnouncement(
+                  labels.deleted(
+                    effectiveWidgets.find(
+                      (w) => w.definition.key === optionsKey
+                    )?.definition.title ?? optionsKey
+                  )
+                );
+              }
+            },
             isTitleInUse: (title) => isTitleInUse(
               widgets.map((w) => w.definition),
               layout,
@@ -5416,7 +5708,10 @@ function resolvePayload(definition, payload, options = {}) {
   } else {
     const result = validateWidgetData(payload, {
       widgetKey: definition.key,
-      expectedKind: definition.kind
+      expectedKind: loadViewKind(
+        definition,
+        options.viewValues?.[definition.key]
+      )
     });
     if (!result.ok) {
       return { definition, status: "error", error: result.error };
@@ -5427,7 +5722,14 @@ function resolvePayload(definition, payload, options = {}) {
   if (emptyText !== null) {
     return { definition, status: "empty", emptyText };
   }
-  return { definition, status: "ok", data: checked };
+  return {
+    definition,
+    status: "ok",
+    data: checked,
+    ...hasViews(definition) ? {
+      view: loadViewKey(definition, options.viewValues?.[definition.key])
+    } : {}
+  };
 }
 function failedWidget(definition, error) {
   return { definition, status: "error", error };
@@ -5436,8 +5738,15 @@ function loadingWidgets(definitions) {
   return definitions.map((definition) => ({ definition, status: "loading" }));
 }
 function cacheKeyFor(definition, options, values) {
-  const base = options.cacheKey === void 0 ? definition.key : options.cacheKey(definition);
-  return values === void 0 ? base : `${base}${optionsCacheSuffix(definition, values, options)}`;
+  const base = options.cacheKey === void 0 ? definition.sourceKey ?? definition.key : options.cacheKey(definition);
+  const view = loadViewKey(
+    definition,
+    options.viewValues?.[definition.key]
+  );
+  const viewPart = view === BASE_VIEW_KEY ? "" : `view=${encodeURIComponent(view)}`;
+  const optionPart = values === void 0 ? "" : optionsCacheSuffix(definition, values, options);
+  if (viewPart === "") return `${base}${optionPart}`;
+  return optionPart === "" ? `${base}?${viewPart}` : `${base}?${viewPart}&${optionPart.slice(1)}`;
 }
 function optionValuesFor(definition, options) {
   return resolveOptionValues(
@@ -5448,6 +5757,9 @@ function optionValuesFor(definition, options) {
 }
 function finalizeWidget(widget, values) {
   if (Object.keys(values).length === 0) return widget;
+  if (widget.status === "ok" && widget.view !== void 0 && widget.view !== BASE_VIEW_KEY) {
+    return { ...widget, options: values };
+  }
   if (widget.status === "ok") {
     const data = applyClientOptions(
       widget.definition,
@@ -5498,7 +5810,8 @@ async function resolveWidgetUnapplied(definition, provider, context, options = {
         if (controller.signal.aborted) throw new LoadInterruption();
         return provider(context, definition, {
           signal: controller.signal,
-          options: values
+          options: values,
+          view: loadViewKey(definition, options.viewValues?.[definition.key])
         });
       }),
       interrupted
@@ -5546,9 +5859,18 @@ function createWidgetLoader(options) {
       ([key, values]) => values === void 0 ? [] : [[key, values]]
     )
   );
+  const chosenViews = new Map(
+    Object.entries(baseOptions.viewValues ?? {}).flatMap(
+      ([key, view]) => view === void 0 ? [] : [[key, view]]
+    )
+  );
   const resolveOptions = baseOptions;
   function currentOptions() {
-    return { ...resolveOptions, optionValues: Object.fromEntries(chosen) };
+    return {
+      ...resolveOptions,
+      optionValues: Object.fromEntries(chosen),
+      viewValues: Object.fromEntries(chosenViews)
+    };
   }
   const unapplied = /* @__PURE__ */ new Map();
   const visible = widgetsFor(definitions, context.roles);
@@ -5610,7 +5932,11 @@ function createWidgetLoader(options) {
       }
     }
     if (!isCurrent()) return;
-    const provider = Object.prototype.hasOwnProperty.call(providers, key) ? providers[key] : void 0;
+    const providerKey = definition.sourceKey ?? key;
+    const provider = Object.prototype.hasOwnProperty.call(
+      providers,
+      providerKey
+    ) ? providers[providerKey] : void 0;
     const result = await resolveWidgetUnapplied(definition, provider, context, {
       ...runOptions,
       signal: controller.signal
@@ -5677,6 +6003,23 @@ function createWidgetLoader(options) {
     }
     start(definition, true);
   }
+  function setView(key, view) {
+    if (disposed) return;
+    const definition = definitionFor(key);
+    if (definition === void 0) return;
+    const before = loadViewKey(definition, chosenViews.get(key));
+    if (view === void 0 || view === "") chosenViews.delete(key);
+    else chosenViews.set(key, view);
+    const after = loadViewKey(definition, chosenViews.get(key));
+    if (before === after || !started.has(key)) return;
+    const current = snapshot.find(
+      (widget) => widget.definition.key === key
+    );
+    if (current !== void 0 && current.status !== "loading") {
+      replace(key, { definition, status: "loading" });
+    }
+    start(definition, true);
+  }
   function dispose() {
     disposed = true;
     abortAll(new Error("The widget loader was disposed."));
@@ -5695,6 +6038,7 @@ function createWidgetLoader(options) {
     loadAll,
     refresh,
     setOptions,
+    setView,
     dispose
   };
 }
@@ -5710,7 +6054,8 @@ function useWidgets(definitions, providers, context, options = {}) {
     signal,
     cache,
     cacheKey,
-    optionValues
+    optionValues,
+    viewValues
   } = options;
   const placeholders = useMemo(
     () => loadingWidgets(widgetsFor(definitions, context.roles)),
@@ -5722,6 +6067,8 @@ function useWidgets(definitions, providers, context, options = {}) {
   const gridRef = useRef(null);
   const optionValuesRef = useRef(optionValues);
   optionValuesRef.current = optionValues;
+  const viewValuesRef = useRef(viewValues);
+  viewValuesRef.current = viewValues;
   useEffect(() => {
     const created = createWidgetLoader({
       definitions,
@@ -5732,7 +6079,8 @@ function useWidgets(definitions, providers, context, options = {}) {
       ...signal === void 0 ? {} : { signal },
       ...cache === void 0 ? {} : { cache },
       ...cacheKey === void 0 ? {} : { cacheKey },
-      ...optionValuesRef.current === void 0 ? {} : { optionValues: optionValuesRef.current }
+      ...optionValuesRef.current === void 0 ? {} : { optionValues: optionValuesRef.current },
+      ...viewValuesRef.current === void 0 ? {} : { viewValues: viewValuesRef.current }
     });
     loaderRef.current = created;
     setWidgets(created.getSnapshot());
@@ -5811,6 +6159,16 @@ function useWidgets(definitions, providers, context, options = {}) {
       if (chosen !== void 0) loader.setOptions(key, chosen);
     }
   }, [loader, optionSignature]);
+  const viewSignature = JSON.stringify(viewValues ?? {});
+  useEffect(() => {
+    if (loader === null) return;
+    for (const [key, view] of Object.entries(viewValuesRef.current ?? {})) {
+      loader.setView(key, view);
+    }
+  }, [loader, viewSignature]);
+  const setView = useCallback((key, view) => {
+    loaderRef.current?.setView(key, view);
+  }, []);
   const setOptions = useCallback(
     (key, chosen) => {
       loaderRef.current?.setOptions(key, chosen);
@@ -5820,7 +6178,7 @@ function useWidgets(definitions, providers, context, options = {}) {
   const refresh = useCallback((key) => {
     loaderRef.current?.refresh(key);
   }, []);
-  return { widgets, refresh, setOptions, gridRef };
+  return { widgets, refresh, setOptions, setView, gridRef };
 }
 
 export { AlertListWidget, BarListWidget, DEFAULT_LABELS, DEFAULT_SERIES_COLORS, Dashboard, GaugeWidget, GraphWidget, KpiWidget, ResolvedWidgetCard, TableWidget, TextWidget, Thumbnail, WidgetCard, WidgetContent, WidgetDetail, WidgetDetailDialog, WidgetGrid, WidgetLink, WidgetOptionsDialog, WidgetSettingsProvider, barPath, buildChartModel, describeChart, joinClassNames, seriesColor, useDetailData, useStoredLayout, useWidgetSettings, useWidgets, widgetTitle };