@richardmcquiston01/dashboard-widgets-toolkit 0.1.0

package/dist/core.cjs

@@ -0,0 +1,836 @@
+'use strict';
+
+// src/core/payload.ts
+var WIDGET_KINDS = [
+  "TEXT",
+  "KPI",
+  "GAUGE",
+  "TABLE",
+  "BAR_LIST",
+  "ALERT_LIST",
+  "GRAPH"
+];
+function isWidgetKind(value) {
+  return typeof value === "string" && WIDGET_KINDS.includes(value);
+}
+var VALUE_FORMATS = ["number", "currency", "percent"];
+var MAX_GRAPH_SERIES = 8;
+var DEFAULT_EMPTY_TEXT = "Nothing to show yet.";
+function emptyWidget(text = DEFAULT_EMPTY_TEXT) {
+  return { empty: true, text };
+}
+function isWidgetEmptyState(payload) {
+  return "empty" in payload && payload.empty === true;
+}
+function emptyTextFor(payload) {
+  if (isWidgetEmptyState(payload)) {
+    return payload.text;
+  }
+  switch (payload.kind) {
+    case "TABLE":
+      return payload.rows.length === 0 ? DEFAULT_EMPTY_TEXT : null;
+    case "BAR_LIST":
+      return payload.items.length === 0 ? DEFAULT_EMPTY_TEXT : null;
+    case "ALERT_LIST":
+      return payload.items.length === 0 ? payload.emptyText : null;
+    case "GRAPH":
+      return payload.series.every((series) => series.points.length === 0) ? DEFAULT_EMPTY_TEXT : null;
+    case "TEXT":
+    case "KPI":
+    case "GAUGE":
+      return null;
+  }
+}
+
+// src/core/compat.ts
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function upgradeLegacyWidgetData(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const record = value;
+  if (record["kind"] === "TABLE" && isStringArray(record["columns"]) && Array.isArray(record["rows"]) && record["rows"].every(isStringArray)) {
+    const rows = record["rows"];
+    return {
+      ...record,
+      columns: record["columns"].map((label) => ({ label })),
+      rows: rows.map((row) => row.map((text) => ({ text })))
+    };
+  }
+  if (record["kind"] === "GRAPH" && Array.isArray(record["points"]) && record["series"] === void 0) {
+    const { points, ...rest } = record;
+    return {
+      ...rest,
+      series: [{ name: "Value", points }],
+      chartType: "bar",
+      valueFormat: "number"
+    };
+  }
+  return value;
+}
+function fromLegacyDefinition(legacy) {
+  if (!isWidgetKind(legacy.viewType)) {
+    return null;
+  }
+  return {
+    key: legacy.widgetKey,
+    title: legacy.title,
+    ...legacy.description === null ? {} : { description: legacy.description },
+    kind: legacy.viewType,
+    sortOrder: legacy.sortOrder
+  };
+}
+
+// src/core/definition.ts
+var WIDGET_SIZES = ["small", "medium", "large", "full"];
+function defineWidget(definition) {
+  return definition;
+}
+function sortDefinitions(definitions) {
+  return definitions.map((definition, index) => ({ definition, index })).sort(
+    (a, b) => (a.definition.sortOrder ?? 0) - (b.definition.sortOrder ?? 0) || a.index - b.index
+  ).map(({ definition }) => definition);
+}
+function isWidgetVisibleTo(definition, roles) {
+  if (definition.active === false) {
+    return false;
+  }
+  if (definition.roles === void 0 || definition.roles.length === 0) {
+    return true;
+  }
+  if (roles === void 0) {
+    return false;
+  }
+  return definition.roles.some((role) => roles.includes(role));
+}
+
+// src/core/format.ts
+var DEFAULT_CURRENCY = "USD";
+function localeArgument(locale) {
+  return locale === void 0 || typeof locale === "string" ? locale : [...locale];
+}
+function numberFormat(locale, options) {
+  try {
+    return new Intl.NumberFormat(localeArgument(locale), options);
+  } catch {
+    const { style: _style, currency: _currency, ...rest } = options;
+    return new Intl.NumberFormat(void 0, rest);
+  }
+}
+function formatValue(value, format, options = {}) {
+  if (!Number.isFinite(value)) {
+    return "\u2014";
+  }
+  const compact = options.compact ? { notation: "compact", maximumFractionDigits: 1 } : {};
+  switch (format) {
+    case "number":
+      return numberFormat(options.locale, {
+        maximumFractionDigits: 2,
+        ...compact
+      }).format(value);
+    case "currency": {
+      const currency = (options.currency ?? DEFAULT_CURRENCY).toUpperCase();
+      const formatter = numberFormat(options.locale, {
+        style: "currency",
+        currency,
+        ...compact
+      });
+      const text = formatter.format(value);
+      return formatter.resolvedOptions().style === "currency" ? text : `${text} ${currency}`;
+    }
+    case "percent":
+      return numberFormat(options.locale, {
+        style: "percent",
+        maximumFractionDigits: 1,
+        ...compact
+      }).format(value);
+  }
+}
+function formatCount(value, locale) {
+  return formatValue(value, "number", { locale });
+}
+function shareOf(part, total) {
+  return total <= 0 ? 0 : Math.round(part / total * 100);
+}
+function percentChange(current, previous) {
+  if (previous === null || previous === void 0 || previous === 0 || !Number.isFinite(previous) || !Number.isFinite(current)) {
+    return null;
+  }
+  return (current - previous) / Math.abs(previous) * 100;
+}
+function formatPercentChange(change, locale) {
+  const digits = Math.abs(change) < 10 ? 1 : 0;
+  const rounded = Number(change.toFixed(digits));
+  if (rounded === 0) {
+    return "\xB10%";
+  }
+  return numberFormat(locale, {
+    style: "percent",
+    maximumFractionDigits: digits,
+    signDisplay: "exceptZero"
+  }).format(rounded / 100);
+}
+var DEFAULT_COMPARISON_LABEL = "previous period";
+function kpiDelta(current, previous, options = {}) {
+  const percent = percentChange(current, previous);
+  if (percent === null) {
+    return null;
+  }
+  const text = formatPercentChange(percent, options.locale);
+  const direction = text === "\xB10%" ? "flat" : percent > 0 ? "up" : "down";
+  const higherIsBetter = options.higherIsBetter ?? true;
+  const sentiment = direction === "flat" ? "neutral" : direction === "up" === higherIsBetter ? "good" : "bad";
+  return {
+    percent,
+    direction,
+    sentiment,
+    text,
+    description: `${text} vs ${options.comparisonLabel ?? DEFAULT_COMPARISON_LABEL}`
+  };
+}
+
+// src/core/layout.ts
+var EMPTY_LAYOUT = Object.freeze({
+  order: Object.freeze([]),
+  hidden: Object.freeze([]),
+  minimized: Object.freeze([])
+});
+function uniqueStrings(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry === "string" && entry !== "") seen.add(entry);
+  }
+  return [...seen];
+}
+function parseLayout(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return EMPTY_LAYOUT;
+    }
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return EMPTY_LAYOUT;
+  }
+  const record = value;
+  const order = uniqueStrings(record["order"]);
+  const hidden = uniqueStrings(record["hidden"]);
+  const minimized = uniqueStrings(record["minimized"]);
+  if (order.length === 0 && hidden.length === 0 && minimized.length === 0) {
+    return EMPTY_LAYOUT;
+  }
+  return { order, hidden, minimized };
+}
+function serializeLayout(layout) {
+  return JSON.stringify({
+    order: [...layout.order],
+    hidden: [...layout.hidden],
+    minimized: [...layout.minimized]
+  });
+}
+function bySortOrder(items) {
+  return items.map((item, index) => ({ item, index })).sort(
+    (a, b) => (a.item.sortOrder ?? 0) - (b.item.sortOrder ?? 0) || a.index - b.index
+  ).map(({ item }) => item);
+}
+function visibleWidgets(definitions, layout) {
+  const hidden = new Set(layout.hidden);
+  const visible = definitions.filter((d) => !hidden.has(d.key));
+  const byKey = new Map(visible.map((d) => [d.key, d]));
+  const ordered = [];
+  for (const key of layout.order) {
+    const definition = byKey.get(key);
+    if (definition !== void 0) {
+      ordered.push(definition);
+      byKey.delete(key);
+    }
+  }
+  for (const definition of bySortOrder(visible)) {
+    if (byKey.has(definition.key)) ordered.push(definition);
+  }
+  return ordered;
+}
+function hiddenWidgets(definitions, layout) {
+  const hidden = new Set(layout.hidden);
+  return bySortOrder(definitions.filter((d) => hidden.has(d.key)));
+}
+function moveWidget(definitions, layout, key, toIndex) {
+  const current = visibleWidgets(definitions, layout).map(
+    (d) => d.key
+  );
+  const fromIndex = current.indexOf(key);
+  if (fromIndex === -1 || !Number.isInteger(toIndex) || toIndex < 0 || toIndex >= current.length || toIndex === fromIndex) {
+    return layout;
+  }
+  const next = [...current];
+  next.splice(fromIndex, 1);
+  next.splice(toIndex, 0, key);
+  return { ...layout, order: next };
+}
+function moveWidgetBy(definitions, layout, key, offset) {
+  const current = visibleWidgets(definitions, layout).map(
+    (d) => d.key
+  );
+  const fromIndex = current.indexOf(key);
+  if (fromIndex === -1) return layout;
+  const toIndex = Math.max(
+    0,
+    Math.min(current.length - 1, fromIndex + Math.trunc(offset))
+  );
+  return moveWidget(definitions, layout, key, toIndex);
+}
+function moveWidgetUp(definitions, layout, key) {
+  return moveWidgetBy(definitions, layout, key, -1);
+}
+function moveWidgetDown(definitions, layout, key) {
+  return moveWidgetBy(definitions, layout, key, 1);
+}
+function isHidden(layout, key) {
+  return layout.hidden.includes(key);
+}
+function isMinimized(layout, key) {
+  return layout.minimized.includes(key);
+}
+function hideWidget(layout, key) {
+  if (isHidden(layout, key)) return layout;
+  return { ...layout, hidden: [...layout.hidden, key] };
+}
+function showWidget(layout, key) {
+  if (!isHidden(layout, key)) return layout;
+  return {
+    ...layout,
+    hidden: layout.hidden.filter((k) => k !== key),
+    minimized: layout.minimized.filter((k) => k !== key)
+  };
+}
+function toggleHidden(layout, key) {
+  return isHidden(layout, key) ? showWidget(layout, key) : hideWidget(layout, key);
+}
+function minimizeWidget(layout, key) {
+  if (isMinimized(layout, key)) return layout;
+  return { ...layout, minimized: [...layout.minimized, key] };
+}
+function restoreWidget(layout, key) {
+  if (!isMinimized(layout, key)) return layout;
+  return { ...layout, minimized: layout.minimized.filter((k) => k !== key) };
+}
+function toggleMinimized(layout, key) {
+  return isMinimized(layout, key) ? restoreWidget(layout, key) : minimizeWidget(layout, key);
+}
+function pruneLayout(definitions, layout) {
+  const known = new Set(definitions.map((d) => d.key));
+  const keep = (keys) => keys.filter((k) => known.has(k));
+  const next = {
+    order: keep(layout.order),
+    hidden: keep(layout.hidden),
+    minimized: keep(layout.minimized)
+  };
+  return next.order.length === layout.order.length && next.hidden.length === layout.hidden.length && next.minimized.length === layout.minimized.length ? layout : next;
+}
+
+// src/core/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function describeUnknownError(cause) {
+  if (cause instanceof Error) {
+    return cause.message === "" ? cause.name : cause.message;
+  }
+  if (typeof cause === "string") {
+    return cause;
+  }
+  try {
+    const json = JSON.stringify(cause);
+    return json ?? String(cause);
+  } catch {
+    return String(cause);
+  }
+}
+
+// src/core/url.ts
+var SCHEME_PATTERN = /^([a-z][a-z0-9+.-]*):/i;
+var IGNORED_IN_SCHEME = /[\u0000- \u007f]/g;
+function schemeOf(url) {
+  const match = SCHEME_PATTERN.exec(
+    url.replace(IGNORED_IN_SCHEME, "")
+  );
+  return match === null ? null : (match[1] ?? "").toLowerCase();
+}
+function isSafeHref(url) {
+  if (url.trim() === "") {
+    return false;
+  }
+  const scheme = schemeOf(url);
+  return scheme === null || scheme === "http" || scheme === "https" || scheme === "mailto";
+}
+function isSafeImageUrl(url) {
+  if (url.trim() === "") {
+    return false;
+  }
+  const scheme = schemeOf(url);
+  return scheme === null || scheme === "http" || scheme === "https";
+}
+
+// src/core/validate.ts
+var MAX_REPORTED_PROBLEMS = 10;
+function describeType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  return typeof value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function join(path, field) {
+  return path === "" ? field : `${path}.${field}`;
+}
+function requireString(record, field, path, problems) {
+  const value = record[field];
+  if (typeof value !== "string") {
+    problems.push(
+      `${join(path, field)} must be a string, got ${describeType(value)}.`
+    );
+  }
+}
+function optionalString(record, field, path, problems) {
+  if (record[field] !== void 0) {
+    requireString(record, field, path, problems);
+  }
+}
+function requireNumber(record, field, path, problems) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    problems.push(
+      `${join(path, field)} must be a finite number, got ${describeType(value)}.`
+    );
+  }
+}
+function optionalNumber(record, field, path, problems) {
+  if (record[field] !== void 0) {
+    requireNumber(record, field, path, problems);
+  }
+}
+function optionalBoolean(record, field, path, problems) {
+  const value = record[field];
+  if (value !== void 0 && typeof value !== "boolean") {
+    problems.push(
+      `${join(path, field)} must be a boolean, got ${describeType(value)}.`
+    );
+  }
+}
+function optionalUrl(record, field, path, problems, isSafe, allowed) {
+  const value = record[field];
+  if (value === void 0) return;
+  if (typeof value !== "string") {
+    problems.push(
+      `${join(path, field)} must be a string, got ${describeType(value)}.`
+    );
+  } else if (!isSafe(value)) {
+    problems.push(
+      `${join(path, field)} must be ${allowed}, got ${JSON.stringify(value.slice(0, 80))}.`
+    );
+  }
+}
+function requireArray(record, field, path, problems) {
+  const value = record[field];
+  if (!Array.isArray(value)) {
+    problems.push(
+      `${join(path, field)} must be an array, got ${describeType(value)}.`
+    );
+    return null;
+  }
+  return value;
+}
+function requireOneOf(record, field, options, path, problems) {
+  const value = record[field];
+  if (typeof value !== "string" || !options.includes(value)) {
+    problems.push(
+      `${join(path, field)} must be one of ${options.map((o) => `"${o}"`).join(", ")}, got ${typeof value === "string" ? JSON.stringify(value) : describeType(value)}.`
+    );
+  }
+}
+function eachRecord(items, path, problems, check) {
+  items.forEach((item, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (isRecord(item)) {
+      check(item, itemPath);
+    } else {
+      problems.push(
+        `${itemPath} must be an object, got ${describeType(item)}.`
+      );
+    }
+  });
+}
+var HREF_RULE = "an http(s), mailto or relative URL";
+var IMAGE_RULE = "an http(s) or relative URL";
+function checkPayloadFields(kind, data, problems) {
+  switch (kind) {
+    case "TEXT":
+      requireString(data, "value", "", problems);
+      requireString(data, "label", "", problems);
+      return;
+    case "KPI":
+      requireNumber(data, "value", "", problems);
+      if (data["previous"] !== null) {
+        optionalNumber(data, "previous", "", problems);
+      }
+      requireOneOf(data, "format", VALUE_FORMATS, "", problems);
+      optionalString(data, "currency", "", problems);
+      requireString(data, "label", "", problems);
+      optionalString(data, "hint", "", problems);
+      optionalBoolean(data, "higherIsBetter", "", problems);
+      return;
+    case "GAUGE":
+      requireNumber(data, "value", "", problems);
+      requireNumber(data, "max", "", problems);
+      requireString(data, "label", "", problems);
+      if (typeof data["max"] === "number" && data["max"] <= 0) {
+        problems.push(`max must be greater than 0, got ${data["max"]}.`);
+      }
+      return;
+    case "TABLE": {
+      const columns = requireArray(data, "columns", "", problems);
+      if (columns !== null) {
+        eachRecord(columns, "columns", problems, (column, path) => {
+          requireString(column, "label", path, problems);
+          optionalBoolean(column, "numeric", path, problems);
+        });
+      }
+      const rows = requireArray(data, "rows", "", problems);
+      if (rows !== null) {
+        rows.forEach((row, rowIndex) => {
+          const rowPath = `rows[${rowIndex}]`;
+          if (!Array.isArray(row)) {
+            problems.push(
+              `${rowPath} must be an array of cells, got ${describeType(row)}.`
+            );
+            return;
+          }
+          if (columns !== null && row.length !== columns.length) {
+            problems.push(
+              `${rowPath} has ${row.length} cell(s) but there are ${columns.length} column(s).`
+            );
+          }
+          eachRecord(row, rowPath, problems, (cell, cellPath) => {
+            requireString(cell, "text", cellPath, problems);
+            optionalUrl(
+              cell,
+              "href",
+              cellPath,
+              problems,
+              isSafeHref,
+              HREF_RULE
+            );
+          });
+        });
+      }
+      optionalString(data, "footer", "", problems);
+      return;
+    }
+    case "BAR_LIST": {
+      const items = requireArray(data, "items", "", problems);
+      if (items !== null) {
+        eachRecord(items, "items", problems, (item, path) => {
+          requireString(item, "label", path, problems);
+          requireNumber(item, "value", path, problems);
+          optionalString(item, "display", path, problems);
+        });
+      }
+      optionalNumber(data, "total", "", problems);
+      return;
+    }
+    case "ALERT_LIST": {
+      const items = requireArray(data, "items", "", problems);
+      if (items !== null) {
+        eachRecord(items, "items", problems, (item, path) => {
+          requireString(item, "title", path, problems);
+          optionalUrl(item, "href", path, problems, isSafeHref, HREF_RULE);
+          optionalUrl(
+            item,
+            "thumbnailUrl",
+            path,
+            problems,
+            isSafeImageUrl,
+            IMAGE_RULE
+          );
+          requireString(item, "valueLabel", path, problems);
+          optionalString(item, "detail", path, problems);
+        });
+      }
+      requireNumber(data, "total", "", problems);
+      requireString(data, "emptyText", "", problems);
+      if (items !== null && typeof data["total"] === "number" && data["total"] < items.length) {
+        problems.push(
+          `total (${data["total"]}) must be at least the number of items (${items.length}).`
+        );
+      }
+      return;
+    }
+    case "GRAPH": {
+      const series = requireArray(data, "series", "", problems);
+      if (series !== null) {
+        if (series.length > MAX_GRAPH_SERIES) {
+          problems.push(
+            `series has ${series.length} entries; at most ${MAX_GRAPH_SERIES} are allowed (fold the rest into "Other").`
+          );
+        }
+        eachRecord(series, "series", problems, (entry, path) => {
+          requireString(entry, "name", path, problems);
+          const points = requireArray(entry, "points", path, problems);
+          if (points !== null) {
+            eachRecord(
+              points,
+              `${path}.points`,
+              problems,
+              (point, pointPath) => {
+                requireString(point, "label", pointPath, problems);
+                requireNumber(point, "value", pointPath, problems);
+              }
+            );
+          }
+        });
+      }
+      requireOneOf(data, "chartType", ["bar", "line"], "", problems);
+      requireOneOf(data, "valueFormat", VALUE_FORMATS, "", problems);
+      optionalString(data, "currency", "", problems);
+      optionalString(data, "xLabel", "", problems);
+      return;
+    }
+  }
+}
+function formatProblems(prefix, problems) {
+  const shown = problems.slice(0, MAX_REPORTED_PROBLEMS);
+  const more = problems.length - shown.length;
+  return `${prefix}: ${shown.join(" ")}${more > 0 ? ` (and ${more} more problem(s))` : ""}`;
+}
+function validateWidgetData(value, options = {}) {
+  const subject = options.widgetKey === void 0 ? "Widget data" : `Widget ${JSON.stringify(options.widgetKey)}`;
+  if (!isRecord(value)) {
+    return err(`${subject}: must be an object, got ${describeType(value)}.`);
+  }
+  if (value["empty"] === true) {
+    if (typeof value["text"] !== "string") {
+      return err(
+        `${subject} (empty): text must be a string, got ${describeType(value["text"])}.`
+      );
+    }
+    return ok(value);
+  }
+  const kind = value["kind"];
+  if (!isWidgetKind(kind)) {
+    return err(
+      `${subject}: kind must be one of ${WIDGET_KINDS.join(", ")} (or the payload must be {"empty": true, "text": ...}), got ${typeof kind === "string" ? JSON.stringify(kind) : describeType(kind)}.`
+    );
+  }
+  if (options.expectedKind !== void 0 && kind !== options.expectedKind) {
+    return err(
+      `${subject}: expected kind ${options.expectedKind} from its definition, got ${kind}.`
+    );
+  }
+  const problems = [];
+  checkPayloadFields(kind, value, problems);
+  if (problems.length > 0) {
+    return err(formatProblems(`${subject} (${kind})`, problems));
+  }
+  return ok(value);
+}
+function validateWidgetDefinition(value) {
+  if (!isRecord(value)) {
+    return err(
+      `Widget definition: must be an object, got ${describeType(value)}.`
+    );
+  }
+  const subject = typeof value["key"] === "string" ? `Widget definition ${JSON.stringify(value["key"])}` : "Widget definition";
+  const problems = [];
+  requireString(value, "key", "", problems);
+  if (value["key"] === "") {
+    problems.push("key must not be empty.");
+  }
+  requireString(value, "title", "", problems);
+  optionalString(value, "description", "", problems);
+  requireOneOf(value, "kind", WIDGET_KINDS, "", problems);
+  optionalNumber(value, "sortOrder", "", problems);
+  if (value["roles"] !== void 0) {
+    const roles = requireArray(value, "roles", "", problems);
+    roles?.forEach((role, index) => {
+      if (typeof role !== "string") {
+        problems.push(
+          `roles[${index}] must be a string, got ${describeType(role)}.`
+        );
+      }
+    });
+  }
+  optionalBoolean(value, "active", "", problems);
+  if (value["defaultSize"] !== void 0) {
+    requireOneOf(value, "defaultSize", WIDGET_SIZES, "", problems);
+  }
+  if (problems.length > 0) {
+    return err(formatProblems(subject, problems));
+  }
+  return ok(value);
+}
+
+// src/core/resolve.ts
+function resolvePayload(definition, payload, options = {}) {
+  let checked;
+  if (options.validate === false) {
+    checked = payload;
+  } else {
+    const result = validateWidgetData(payload, {
+      widgetKey: definition.key,
+      expectedKind: definition.kind
+    });
+    if (!result.ok) {
+      return { definition, status: "error", error: result.error };
+    }
+    checked = result.value;
+  }
+  const emptyText = emptyTextFor(checked);
+  if (emptyText !== null) {
+    return { definition, status: "empty", emptyText };
+  }
+  return { definition, status: "ok", data: checked };
+}
+function failedWidget(definition, error) {
+  return { definition, status: "error", error };
+}
+function loadingWidgets(definitions) {
+  return definitions.map((definition) => ({ definition, status: "loading" }));
+}
+async function resolveWidget(definition, provider, context, options = {}) {
+  if (provider === void 0) {
+    return failedWidget(
+      definition,
+      `Widget ${JSON.stringify(definition.key)}: no provider is registered for this key.`
+    );
+  }
+  let payload;
+  try {
+    payload = await provider(context, definition);
+  } catch (cause) {
+    return failedWidget(
+      definition,
+      `Widget ${JSON.stringify(definition.key)}: provider failed: ${describeUnknownError(cause)}`
+    );
+  }
+  return resolvePayload(definition, payload, options);
+}
+function widgetsFor(definitions, roles) {
+  return sortDefinitions(
+    definitions.filter((definition) => isWidgetVisibleTo(definition, roles))
+  );
+}
+async function resolveWidgets(definitions, providers, context, options = {}) {
+  const visible = widgetsFor(definitions, context.roles);
+  return Promise.all(
+    visible.map(
+      (definition) => resolveWidget(
+        definition,
+        Object.prototype.hasOwnProperty.call(providers, definition.key) ? providers[definition.key] : void 0,
+        context,
+        options
+      )
+    )
+  );
+}
+
+// src/core/scale.ts
+function niceStep(value) {
+  if (!(value > 0) || !Number.isFinite(value)) return 1;
+  const exponent = Math.floor(Math.log10(value));
+  const fraction = value / 10 ** exponent;
+  const nice = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
+  return nice * 10 ** exponent;
+}
+function niceDomain(values, tickCount = 4) {
+  const finite = values.filter((v) => Number.isFinite(v));
+  let low = Math.min(0, ...finite);
+  let high = Math.max(0, ...finite);
+  if (low === high) {
+    high = 1;
+    low = 0;
+  }
+  const step = niceStep((high - low) / Math.max(1, tickCount));
+  const min = Math.floor(low / step) * step;
+  const max = Math.ceil(high / step) * step;
+  const ticks = [];
+  const count = Math.round((max - min) / step);
+  for (let index = 0; index <= count; index++) {
+    ticks.push(Number((min + index * step).toPrecision(12)));
+  }
+  return { min, max, ticks };
+}
+function labelStride(count, maxLabels = 6) {
+  return Math.max(1, Math.ceil(count / Math.max(1, maxLabels)));
+}
+
+exports.DEFAULT_COMPARISON_LABEL = DEFAULT_COMPARISON_LABEL;
+exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
+exports.DEFAULT_EMPTY_TEXT = DEFAULT_EMPTY_TEXT;
+exports.EMPTY_LAYOUT = EMPTY_LAYOUT;
+exports.MAX_GRAPH_SERIES = MAX_GRAPH_SERIES;
+exports.MAX_REPORTED_PROBLEMS = MAX_REPORTED_PROBLEMS;
+exports.VALUE_FORMATS = VALUE_FORMATS;
+exports.WIDGET_KINDS = WIDGET_KINDS;
+exports.WIDGET_SIZES = WIDGET_SIZES;
+exports.defineWidget = defineWidget;
+exports.describeUnknownError = describeUnknownError;
+exports.emptyTextFor = emptyTextFor;
+exports.emptyWidget = emptyWidget;
+exports.err = err;
+exports.failedWidget = failedWidget;
+exports.formatCount = formatCount;
+exports.formatPercentChange = formatPercentChange;
+exports.formatValue = formatValue;
+exports.fromLegacyDefinition = fromLegacyDefinition;
+exports.hiddenWidgets = hiddenWidgets;
+exports.hideWidget = hideWidget;
+exports.isHidden = isHidden;
+exports.isMinimized = isMinimized;
+exports.isSafeHref = isSafeHref;
+exports.isSafeImageUrl = isSafeImageUrl;
+exports.isWidgetEmptyState = isWidgetEmptyState;
+exports.isWidgetKind = isWidgetKind;
+exports.isWidgetVisibleTo = isWidgetVisibleTo;
+exports.kpiDelta = kpiDelta;
+exports.labelStride = labelStride;
+exports.loadingWidgets = loadingWidgets;
+exports.minimizeWidget = minimizeWidget;
+exports.moveWidget = moveWidget;
+exports.moveWidgetBy = moveWidgetBy;
+exports.moveWidgetDown = moveWidgetDown;
+exports.moveWidgetUp = moveWidgetUp;
+exports.niceDomain = niceDomain;
+exports.niceStep = niceStep;
+exports.ok = ok;
+exports.parseLayout = parseLayout;
+exports.percentChange = percentChange;
+exports.pruneLayout = pruneLayout;
+exports.resolvePayload = resolvePayload;
+exports.resolveWidget = resolveWidget;
+exports.resolveWidgets = resolveWidgets;
+exports.restoreWidget = restoreWidget;
+exports.serializeLayout = serializeLayout;
+exports.shareOf = shareOf;
+exports.showWidget = showWidget;
+exports.sortDefinitions = sortDefinitions;
+exports.toggleHidden = toggleHidden;
+exports.toggleMinimized = toggleMinimized;
+exports.upgradeLegacyWidgetData = upgradeLegacyWidgetData;
+exports.validateWidgetData = validateWidgetData;
+exports.validateWidgetDefinition = validateWidgetDefinition;
+exports.visibleWidgets = visibleWidgets;
+exports.widgetsFor = widgetsFor;
+//# sourceMappingURL=core.cjs.map
+//# sourceMappingURL=core.cjs.map