@chipmobilesdk/rn-chart 0.3.0 → 0.5.0

package/lib/commonjs/geometry/types.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EMPTY_GEOMETRY = void 0;
+/**
+ * The single memoized artefact each chart produces.
+ *
+ * `ResolvedGeometry` is keyed on datasource identity, plot rectangle, theme
+ * identity, and formatter identity — and deliberately **not** on selection.
+ * Highlighting a point must repaint the highlight, not recompute every scale
+ * and path string (research.md R3, FR-073).
+ *
+ * PURE. No React, no SVG.
+ */
+
+/** One drawable group. Element count scales with these, never with points. */
+
+/** A target, baseline, or threshold drawn across the plot. */
+
+/** Text the chart draws itself, such as progress values or segment labels. */
+
+/** What a colour ramp runs from and to, for the legend that explains it. */
+
+const EMPTY_GEOMETRY = exports.EMPTY_GEOMETRY = {
+  plot: {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  paths: [],
+  markers: [],
+  labels: [],
+  xTicks: [],
+  yTicks: [],
+  hitRegions: [],
+  incomplete: false
+};
+
+/** Inputs every family geometry builder needs. */
+//# sourceMappingURL=types.js.map

package/lib/commonjs/geometry/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EMPTY_GEOMETRY","exports","plot","x","y","width","height","paths","markers","labels","xTicks","yTicks","hitRegions","incomplete"],"sourceRoot":"../../../src","sources":["geometry/types.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA;;AAcA;;AAQA;;AAUA;;AAwBO,MAAMA,cAAgC,GAAAC,OAAA,CAAAD,cAAA,GAAG;EAC/CE,IAAI,EAAE;IAAEC,CAAC,EAAE,CAAC;IAAEC,CAAC,EAAE,CAAC;IAAEC,KAAK,EAAE,CAAC;IAAEC,MAAM,EAAE;EAAE,CAAC;EACzCC,KAAK,EAAE,EAAE;EACTC,OAAO,EAAE,EAAE;EACXC,MAAM,EAAE,EAAE;EACVC,MAAM,EAAE,EAAE;EACVC,MAAM,EAAE,EAAE;EACVC,UAAU,EAAE,EAAE;EACdC,UAAU,EAAE;AACb,CAAC;;AAED","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,284 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BarChart", {
+  enumerable: true,
+  get: function () {
+    return _charts.BarChart;
+  }
+});
+Object.defineProperty(exports, "ChartLegend", {
+  enumerable: true,
+  get: function () {
+    return _ChartLegend.ChartLegend;
+  }
+});
+Object.defineProperty(exports, "ChartThemeProvider", {
+  enumerable: true,
+  get: function () {
+    return _ChartThemeProvider.ChartThemeProvider;
+  }
+});
+Object.defineProperty(exports, "ColorScaleLegend", {
+  enumerable: true,
+  get: function () {
+    return _ChartLegend.ColorScaleLegend;
+  }
+});
+Object.defineProperty(exports, "DATASET_BUDGETS", {
+  enumerable: true,
+  get: function () {
+    return _budgets.DATASET_BUDGETS;
+  }
+});
+Object.defineProperty(exports, "DistributionChart", {
+  enumerable: true,
+  get: function () {
+    return _charts.DistributionChart;
+  }
+});
+Object.defineProperty(exports, "FAMILY_POSITION_KINDS", {
+  enumerable: true,
+  get: function () {
+    return _datasource.FAMILY_POSITION_KINDS;
+  }
+});
+Object.defineProperty(exports, "HeatmapChart", {
+  enumerable: true,
+  get: function () {
+    return _charts.HeatmapChart;
+  }
+});
+Object.defineProperty(exports, "NON_VALUE_TEXT", {
+  enumerable: true,
+  get: function () {
+    return _format.NON_VALUE_TEXT;
+  }
+});
+Object.defineProperty(exports, "ProgressChart", {
+  enumerable: true,
+  get: function () {
+    return _charts.ProgressChart;
+  }
+});
+Object.defineProperty(exports, "STATUS_PRECEDENCE", {
+  enumerable: true,
+  get: function () {
+    return _state.STATUS_PRECEDENCE;
+  }
+});
+Object.defineProperty(exports, "TimeSeriesChart", {
+  enumerable: true,
+  get: function () {
+    return _charts.TimeSeriesChart;
+  }
+});
+Object.defineProperty(exports, "buildChartSummary", {
+  enumerable: true,
+  get: function () {
+    return _summary.buildChartSummary;
+  }
+});
+Object.defineProperty(exports, "buildLegendEntries", {
+  enumerable: true,
+  get: function () {
+    return _ChartLegend.buildLegendEntries;
+  }
+});
+Object.defineProperty(exports, "buildPointAnnouncement", {
+  enumerable: true,
+  get: function () {
+    return _summary.buildPointAnnouncement;
+  }
+});
+Object.defineProperty(exports, "buildTotalAnnouncement", {
+  enumerable: true,
+  get: function () {
+    return _summary.buildTotalAnnouncement;
+  }
+});
+Object.defineProperty(exports, "chartStrings", {
+  enumerable: true,
+  get: function () {
+    return _strings.chartStrings;
+  }
+});
+Object.defineProperty(exports, "checkBudget", {
+  enumerable: true,
+  get: function () {
+    return _budgets.checkBudget;
+  }
+});
+Object.defineProperty(exports, "defaultChartTheme", {
+  enumerable: true,
+  get: function () {
+    return _theme.defaultChartTheme;
+  }
+});
+Object.defineProperty(exports, "drawsData", {
+  enumerable: true,
+  get: function () {
+    return _state.drawsData;
+  }
+});
+Object.defineProperty(exports, "familyAcceptsPositionKind", {
+  enumerable: true,
+  get: function () {
+    return _datasource.familyAcceptsPositionKind;
+  }
+});
+Object.defineProperty(exports, "findTarget", {
+  enumerable: true,
+  get: function () {
+    return _marker.findTarget;
+  }
+});
+Object.defineProperty(exports, "formatLegendDefault", {
+  enumerable: true,
+  get: function () {
+    return _format.formatLegendDefault;
+  }
+});
+Object.defineProperty(exports, "formatPositionDefault", {
+  enumerable: true,
+  get: function () {
+    return _format.formatPositionDefault;
+  }
+});
+Object.defineProperty(exports, "formatValueDefault", {
+  enumerable: true,
+  get: function () {
+    return _format.formatValueDefault;
+  }
+});
+Object.defineProperty(exports, "isChartError", {
+  enumerable: true,
+  get: function () {
+    return _errors.isChartError;
+  }
+});
+Object.defineProperty(exports, "isKnown", {
+  enumerable: true,
+  get: function () {
+    return _value.isKnown;
+  }
+});
+Object.defineProperty(exports, "isUsableTarget", {
+  enumerable: true,
+  get: function () {
+    return _marker.isUsableTarget;
+  }
+});
+Object.defineProperty(exports, "isWithheld", {
+  enumerable: true,
+  get: function () {
+    return _value.isWithheld;
+  }
+});
+Object.defineProperty(exports, "known", {
+  enumerable: true,
+  get: function () {
+    return _value.known;
+  }
+});
+Object.defineProperty(exports, "notApplicable", {
+  enumerable: true,
+  get: function () {
+    return _value.notApplicable;
+  }
+});
+Object.defineProperty(exports, "participatesInTotals", {
+  enumerable: true,
+  get: function () {
+    return _value.participatesInTotals;
+  }
+});
+Object.defineProperty(exports, "readProgress", {
+  enumerable: true,
+  get: function () {
+    return _marker.readProgress;
+  }
+});
+Object.defineProperty(exports, "resolveFormat", {
+  enumerable: true,
+  get: function () {
+    return _datasource.resolveFormat;
+  }
+});
+Object.defineProperty(exports, "resolveSeriesColor", {
+  enumerable: true,
+  get: function () {
+    return _theme.resolveSeriesColor;
+  }
+});
+Object.defineProperty(exports, "resolveStatus", {
+  enumerable: true,
+  get: function () {
+    return _state.resolveStatus;
+  }
+});
+Object.defineProperty(exports, "resolveUnit", {
+  enumerable: true,
+  get: function () {
+    return _datasource.resolveUnit;
+  }
+});
+Object.defineProperty(exports, "sameSelection", {
+  enumerable: true,
+  get: function () {
+    return _interaction.sameSelection;
+  }
+});
+Object.defineProperty(exports, "seriesRef", {
+  enumerable: true,
+  get: function () {
+    return _format.seriesRef;
+  }
+});
+Object.defineProperty(exports, "sumKnown", {
+  enumerable: true,
+  get: function () {
+    return _value.sumKnown;
+  }
+});
+Object.defineProperty(exports, "suppressesInteraction", {
+  enumerable: true,
+  get: function () {
+    return _state.suppressesInteraction;
+  }
+});
+Object.defineProperty(exports, "unknown", {
+  enumerable: true,
+  get: function () {
+    return _value.unknown;
+  }
+});
+Object.defineProperty(exports, "useChartTheme", {
+  enumerable: true,
+  get: function () {
+    return _ChartThemeProvider.useChartTheme;
+  }
+});
+Object.defineProperty(exports, "withheld", {
+  enumerable: true,
+  get: function () {
+    return _value.withheld;
+  }
+});
+var _value = require("./contract/value.js");
+var _datasource = require("./contract/datasource.js");
+var _marker = require("./contract/marker.js");
+var _format = require("./contract/format.js");
+var _state = require("./contract/state.js");
+var _errors = require("./contract/errors.js");
+var _interaction = require("./contract/interaction.js");
+var _theme = require("./contract/theme.js");
+var _budgets = require("./validation/budgets.js");
+var _charts = require("./react/charts.js");
+var _ChartLegend = require("./react/ChartLegend.js");
+var _ChartThemeProvider = require("./react/ChartThemeProvider.js");
+var _summary = require("./a11y/summary.js");
+var _strings = require("./contract/strings.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_value","require","_datasource","_marker","_format","_state","_errors","_interaction","_theme","_budgets","_charts","_ChartLegend","_ChartThemeProvider","_summary","_strings"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAAA,MAAA,GAAAC,OAAA;AA0BA,IAAAC,WAAA,GAAAD,OAAA;AAUA,IAAAE,OAAA,GAAAF,OAAA;AAMA,IAAAG,OAAA,GAAAH,OAAA;AAiBA,IAAAI,MAAA,GAAAJ,OAAA;AAcA,IAAAK,OAAA,GAAAL,OAAA;AAYA,IAAAM,YAAA,GAAAN,OAAA;AAMA,IAAAO,MAAA,GAAAP,OAAA;AAWA,IAAAQ,QAAA,GAAAR,OAAA;AAYA,IAAAS,OAAA,GAAAT,OAAA;AAQA,IAAAU,YAAA,GAAAV,OAAA;AAEA,IAAAW,mBAAA,GAAAX,OAAA;AAKA,IAAAY,QAAA,GAAAZ,OAAA;AAGA,IAAAa,QAAA,GAAAb,OAAA","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/react/ChartBoundary.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChartBoundary = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _errors = require("../contract/errors.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Per-chart render-failure containment (FR-038a, FR-038b).
+ *
+ * React 19 still has no hook equivalent of an error boundary —
+ * `getDerivedStateFromError` and `componentDidCatch` remain class-only — so
+ * this is a class. Forty lines beats adding a dependency for it.
+ *
+ * Three behaviours are deliberate:
+ *
+ *  - **Reset only on a real change.** The boundary clears its error when the
+ *    datasource identity or chart key changes, never on an unrelated parent
+ *    re-render. A deterministic geometry defect therefore cannot pin the CPU in
+ *    a render-fail-render loop.
+ *  - **Report once per distinct failure.** De-duplicated by signature, so a
+ *    chart re-rendered by a sibling's state change does not re-report.
+ *  - **Redact.** The report carries the chart identity and a catalogue message.
+ *    A third-party exception's own text is never copied in, because we cannot
+ *    promise it is free of data (POL-011).
+ */
+
+class ChartBoundary extends _react.default.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      resetKey: props.resetKey
+    };
+  }
+  static getDerivedStateFromProps(props, state) {
+    if (props.resetKey !== state.resetKey) {
+      // New data: give the chart another chance.
+      return {
+        resetKey: props.resetKey,
+        error: undefined
+      };
+    }
+    return null;
+  }
+  static getDerivedStateFromError() {
+    // This must set the error, not just acknowledge it. Returning an empty
+    // object leaves render() showing the children again, they throw again,
+    // and React escalates past the boundary — which is exactly the
+    // screen-blanking failure this class exists to prevent.
+    //
+    // componentDidCatch then refines this into a report carrying the chart
+    // identity and family.
+    return {
+      error: (0, _errors.chartError)('render', 'renderException')
+    };
+  }
+  componentDidCatch(error, info) {
+    const report = (0, _errors.toFailureReport)(this.props.family, error, this.props.chartId, info?.componentStack ?? undefined);
+    const signature = (0, _errors.failureSignature)(report);
+    if (this.state.reportedSignature === signature) {
+      this.setState({
+        error: report.error
+      });
+      return;
+    }
+    this.setState({
+      error: report.error,
+      reportedSignature: signature
+    });
+    this.props.onFailure?.(report);
+  }
+  render() {
+    if (this.state.error) {
+      return this.props.renderFallback(this.state.error);
+    }
+    return this.props.children;
+  }
+}
+exports.ChartBoundary = ChartBoundary;
+//# sourceMappingURL=ChartBoundary.js.map

package/lib/commonjs/react/ChartBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_errors","e","__esModule","default","ChartBoundary","React","Component","constructor","props","state","resetKey","getDerivedStateFromProps","error","undefined","getDerivedStateFromError","chartError","componentDidCatch","info","report","toFailureReport","family","chartId","componentStack","signature","failureSignature","reportedSignature","setState","onFailure","render","renderFallback","children","exports"],"sourceRoot":"../../../src","sources":["react/ChartBoundary.tsx"],"mappings":";;;;;;AAmBA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAD,OAAA;AAM4B,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AA5B5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AA4BO,MAAMG,aAAa,SAASC,cAAK,CAACC,SAAS,CAAe;EAChEC,WAAWA,CAACC,KAAY,EAAE;IACzB,KAAK,CAACA,KAAK,CAAC;IACZ,IAAI,CAACC,KAAK,GAAG;MAAEC,QAAQ,EAAEF,KAAK,CAACE;IAAS,CAAC;EAC1C;EAEA,OAAOC,wBAAwBA,CAACH,KAAY,EAAEC,KAAY,EAAgB;IACzE,IAAID,KAAK,CAACE,QAAQ,KAAKD,KAAK,CAACC,QAAQ,EAAE;MACtC;MACA,OAAO;QAAEA,QAAQ,EAAEF,KAAK,CAACE,QAAQ;QAAEE,KAAK,EAAEC;MAAU,CAAC;IACtD;IACA,OAAO,IAAI;EACZ;EAEA,OAAOC,wBAAwBA,CAAA,EAAmB;IACjD;IACA;IACA;IACA;IACA;IACA;IACA;IACA,OAAO;MAAEF,KAAK,EAAE,IAAAG,kBAAU,EAAC,QAAQ,EAAE,iBAAiB;IAAE,CAAC;EAC1D;EAESC,iBAAiBA,CAACJ,KAAc,EAAEK,IAAiC,EAAQ;IACnF,MAAMC,MAAM,GAAG,IAAAC,uBAAe,EAC7B,IAAI,CAACX,KAAK,CAACY,MAAM,EACjBR,KAAK,EACL,IAAI,CAACJ,KAAK,CAACa,OAAO,EAClBJ,IAAI,EAAEK,cAAc,IAAIT,SACzB,CAAC;IAED,MAAMU,SAAS,GAAG,IAAAC,wBAAgB,EAACN,MAAM,CAAC;IAC1C,IAAI,IAAI,CAACT,KAAK,CAACgB,iBAAiB,KAAKF,SAAS,EAAE;MAC/C,IAAI,CAACG,QAAQ,CAAC;QAAEd,KAAK,EAAEM,MAAM,CAACN;MAAM,CAAC,CAAC;MACtC;IACD;IAEA,IAAI,CAACc,QAAQ,CAAC;MAAEd,KAAK,EAAEM,MAAM,CAACN,KAAK;MAAEa,iBAAiB,EAAEF;IAAU,CAAC,CAAC;IACpE,IAAI,CAACf,KAAK,CAACmB,SAAS,GAAGT,MAAM,CAAC;EAC/B;EAESU,MAAMA,CAAA,EAAoB;IAClC,IAAI,IAAI,CAACnB,KAAK,CAACG,KAAK,EAAE;MACrB,OAAO,IAAI,CAACJ,KAAK,CAACqB,cAAc,CAAC,IAAI,CAACpB,KAAK,CAACG,KAAK,CAAC;IACnD;IACA,OAAO,IAAI,CAACJ,KAAK,CAACsB,QAAQ;EAC3B;AACD;AAACC,OAAA,CAAA3B,aAAA,GAAAA,aAAA","ignoreList":[]}

package/lib/commonjs/react/ChartFrame.js

@@ -0,0 +1,270 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChartFrame = ChartFrame;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+var _reactNativeSvg = _interopRequireDefault(require("react-native-svg"));
+var _state = require("../contract/state.js");
+var _strings = require("../contract/strings.js");
+var _hitTest = require("../geometry/hitTest.js");
+var _layout = require("../geometry/layout.js");
+var _types = require("../geometry/types.js");
+var _Marks = require("../render/Marks.js");
+var _ChartBoundary = require("./ChartBoundary.js");
+var _ChartLegend = require("./ChartLegend.js");
+var _ChartPlot = require("./ChartPlot.js");
+var _ChartStateOverlay = require("./ChartStateOverlay.js");
+var _ChartThemeProvider = require("./ChartThemeProvider.js");
+var _pointEvent = require("./pointEvent.js");
+var _useChartA11y = require("./useChartA11y.js");
+var _useChartFormatters = require("./useChartFormatters.js");
+var _useChartLayout = require("./useChartLayout.js");
+var _useChartSelection = require("./useChartSelection.js");
+var _useChartStatus = require("./useChartStatus.js");
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * The shared chart shell.
+ *
+ * Every family routes through here, so validation, status resolution, budget
+ * checks, theming, layout, selection, accessibility, and failure containment
+ * are written once and behave identically across all five. The pieces live in
+ * their own hooks and components; this file is the order they run in.
+ *
+ * Layout note (FR-039): the frame imposes **no outer margin**. Insight text is
+ * out of scope for this package, so apps render their own text directly above
+ * or below a chart and must not have to fight a margin they cannot control.
+ */
+
+const DEFAULT_HEIGHT = 220;
+function ChartFrame(props) {
+  const family = props.family;
+  const theme = (0, _ChartThemeProvider.useChartTheme)(props.theme);
+  const strings = (0, _react.useMemo)(() => _strings.chartStrings.resolve(props.strings), [props.strings]);
+  const generatedId = (0, _react.useId)();
+  const instanceKey = props.chartId ?? generatedId;
+  const {
+    validation,
+    error,
+    status
+  } = (0, _useChartStatus.useChartStatus)({
+    datasource: props.datasource,
+    family,
+    chartId: props.chartId,
+    instanceKey,
+    declared: props.status,
+    onFailure: props.onFailure,
+    distributionValues: props.distributionValues
+  });
+  const formatters = (0, _useChartFormatters.useChartFormatters)(props.formatters, props.datasource.format, instanceKey);
+  const layout = (0, _useChartLayout.useChartLayout)(theme, {
+    height: props.height
+  });
+  const geometryInput = (0, _useChartLayout.useGeometryInput)(props.datasource, theme, layout, formatters.geometry, family);
+  const showData = (0, _state.drawsData)(status);
+  const visibility = (0, _useChartSelection.useSeriesVisibility)({
+    controlled: props.hiddenSeriesIds,
+    onVisibilityChange: props.onVisibilityChange,
+    enabled: props.seriesToggleEnabled === true,
+    initiallyHidden: (0, _react.useMemo)(() => props.datasource.series.filter(s => s.hidden).map(s => s.id), [props.datasource.series])
+  });
+
+  // Runtime visibility has to reach the geometry, not just the legend —
+  // otherwise toggling a series greys out its swatch while the line keeps
+  // drawing (FR-049). With nothing hidden the original datasource is returned
+  // by identity, so the common case costs nothing.
+  const hidden = visibility.hidden;
+  const datasource = (0, _react.useMemo)(() => {
+    if (hidden.size === 0) {
+      return props.datasource;
+    }
+    return {
+      ...props.datasource,
+      series: props.datasource.series.map(s => hidden.has(s.id) ? {
+        ...s,
+        hidden: true
+      } : s)
+    };
+  }, [props.datasource, hidden]);
+
+  // The single memoized artefact.
+  //
+  // The dependency list is narrow on purpose. Depending on the whole `props`
+  // object would invalidate the memo whenever any callback identity changed —
+  // and inline arrow callbacks are the norm in app code, so that would defeat
+  // FR-073 in exactly the case it exists for. Selection is absent for the same
+  // reason: highlighting repaints the highlight, it does not rebuild scales.
+  const buildGeometry = props.buildGeometry;
+  const geometry = (0, _react.useMemo)(() => {
+    if (!layout.measured || !showData) {
+      return _types.EMPTY_GEOMETRY;
+    }
+    return buildGeometry(datasource, geometryInput);
+  }, [layout.measured, showData, buildGeometry, datasource, geometryInput]);
+  const selection = (0, _useChartSelection.useChartSelection)({
+    controlled: props.selection,
+    onSelectionChange: props.onSelectionChange,
+    onSelectionUnresolvable: props.onSelectionUnresolvable,
+    hitRegions: geometry.hitRegions,
+    interactionSuppressed: (0, _state.suppressesInteraction)(status),
+    geometryReady: layout.measured && showData && geometry.hitRegions.length > 0
+  });
+  const handlePress = event => {
+    if ((0, _state.suppressesInteraction)(status) || !props.onSelectionChange) {
+      return;
+    }
+    const {
+      locationX,
+      locationY
+    } = event.nativeEvent;
+    if (!(0, _layout.containsPoint)(geometry.plot, locationX, locationY)) {
+      return;
+    }
+    const hit = props.hitTestMode === 'byX' ? (0, _hitTest.hitTestByX)(geometry.hitRegions, locationX) : (0, _hitTest.hitTest)(geometry.hitRegions, locationX, locationY);
+    if (!hit) {
+      selection.select(null, null);
+      return;
+    }
+    const pointEvent = (0, _pointEvent.pointEventFor)(props.datasource, hit.seriesId, hit.pointId);
+    if (pointEvent) {
+      selection.select({
+        seriesId: hit.seriesId,
+        pointId: hit.pointId
+      }, pointEvent);
+    }
+  };
+  const incomplete = geometry.incomplete || validation.totalIncomplete;
+  const interactive = props.accessibility?.interactive ?? Boolean(props.onSelectionChange);
+  const a11y = (0, _useChartA11y.useChartA11y)({
+    datasource: props.datasource,
+    family,
+    status,
+    title: props.title,
+    accessibility: props.accessibility,
+    interactive,
+    incomplete,
+    hitRegions: geometry.hitRegions,
+    selection,
+    formatters,
+    strings
+  });
+  const legendEnabled = props.legend === undefined ? props.defaultLegend ?? false : props.legend !== false;
+  const legendPosition = typeof props.legend === 'object' ? props.legend.position : 'bottom';
+  const legendLabel = formatters.legendLabel;
+  const legendEntries = (0, _react.useMemo)(() => legendEnabled ? (0, _ChartLegend.buildLegendEntries)(props.datasource, theme, hidden, visibility.enabled, family, legendLabel) : [], [legendEnabled, props.datasource, theme, hidden, visibility.enabled, family, legendLabel]);
+  const legend = legendEnabled ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartLegend.ChartLegend, {
+    entries: legendEntries,
+    theme: theme,
+    onToggle: visibility.enabled ? visibility.toggle : undefined,
+    strings: strings
+  }) : null;
+  const plotHeight = (0, _react.useMemo)(() => ({
+    height: props.height ?? DEFAULT_HEIGHT
+  }), [props.height]);
+  const content = /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+    children: [props.title ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+      style: [styles.title, {
+        color: theme.typography.valueLabel.color,
+        fontSize: theme.typography.valueLabel.fontSize
+      }],
+      accessibilityRole: "header",
+      children: props.title
+    }) : null, legendPosition === 'top' ? legend : null, /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+      accessible: true,
+      accessibilityRole: interactive ? 'adjustable' : 'image',
+      accessibilityLabel: a11y.summary,
+      accessibilityValue: a11y.value,
+      accessibilityActions: a11y.actions,
+      onAccessibilityAction: a11y.onAction,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+        style: [styles.plotArea, plotHeight],
+        onLayout: layout.onLayout,
+        children: [layout.measured && showData ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Pressable, {
+          onPress: handlePress,
+          disabled: !props.onSelectionChange,
+          style: _reactNative.StyleSheet.absoluteFill,
+          accessible: false,
+          importantForAccessibility: "no-hide-descendants",
+          children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNativeSvg.default, {
+            width: layout.size.width,
+            height: layout.size.height,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartPlot.ChartPlot, {
+              geometry: geometry,
+              theme: theme,
+              fontSize: layout.fontSize,
+              axes: props.axes ?? 'full'
+            }), selection.resolved && /*#__PURE__*/(0, _jsxRuntime.jsx)(_Marks.SelectionHighlight, {
+              x: selection.resolved.x,
+              y: selection.resolved.y,
+              color: theme.onSurface
+            })]
+          })
+        }) : null, !showData || error ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartStateOverlay.ChartStateOverlay, {
+          status: status,
+          supplied: props.stateContent?.[status],
+          strings: strings,
+          theme: theme,
+          error: error
+        }) : null]
+      })
+    }), legendPosition === 'bottom' ? legend : null, geometry.colorScale && props.legend !== false ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartLegend.ColorScaleLegend, {
+      scale: geometry.colorScale,
+      theme: theme,
+      formatValue: formatters.geometry.formatValue,
+      strings: strings
+    }) : null, incomplete ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+      style: [styles.note, {
+        color: theme.muted,
+        fontSize: theme.typography.axisLabel.fontSize
+      }],
+      children: strings['chart.note.incomplete']
+    }) : null, props.footer]
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+    style: [styles.container, {
+      backgroundColor: theme.surface
+    }, props.style],
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartBoundary.ChartBoundary, {
+      family: props.family,
+      chartId: props.chartId,
+      onFailure: props.onFailure,
+      resetKey: props.datasource,
+      renderFallback: containedError => /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+        accessible: true,
+        accessibilityRole: "image",
+        accessibilityLabel: a11y.summary,
+        style: [styles.plotArea, plotHeight],
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartStateOverlay.ChartFailureOverlay, {
+          supplied: props.stateContent?.error,
+          theme: theme,
+          error: containedError
+        })
+      }),
+      children: content
+    })
+  });
+}
+const styles = _reactNative.StyleSheet.create({
+  // No outer margin: app content must be able to sit flush against a chart.
+  container: {
+    width: '100%'
+  },
+  title: {
+    fontWeight: '600',
+    marginBottom: 4
+  },
+  plotArea: {
+    width: '100%',
+    position: 'relative'
+  },
+  // Colour and type size are applied inline from ChartTheme, so they follow
+  // the consuming app's tokens and the system text scale (UX-001).
+  note: {
+    marginTop: 4
+  }
+});
+//# sourceMappingURL=ChartFrame.js.map