@oxy.so/bloom 4.0.0 → 4.2.0

package/lib/typescript/module/location-puck/shared.d.ts

@@ -0,0 +1,109 @@
+import type { Theme } from '../theme/types';
+import type { LocationPuckMode, LocationPuckState } from './types';
+export interface LocationPuckPaint {
+    /** The live dot — the accent's own solid fill. */
+    dot: string;
+    /** The ring around it: the accent fill's OWN on-colour. */
+    ring: string;
+    /** The dot once the fix is stale: the accent gone, a quiet neutral in its place. */
+    staleDot: string;
+    /** The ring around THAT: the map-chrome surface the quiet neutral was floored against. */
+    staleRing: string;
+    /** The heading cone and the accuracy halo. */
+    cone: string;
+}
+/**
+ * ── THE RING IS THE DOT'S OWN ON-COLOUR, AND THAT IS WHY THERE ARE TWO ──────
+ *
+ * A ring around a dot has one job: make the dot read as a deliberate object
+ * over tiles Bloom cannot see. Bloom cannot measure anything against those
+ * tiles, but it CAN guarantee the ring reads against the dot — and every fill
+ * in this library already ships with the colour that reads on it. So the live
+ * ring is `resolveAccentColors(…, 'solid').foreground` (white for most seeds,
+ * black for a light one like yellow or peach — the pair adapts, which a
+ * hardcoded white ring does not), and the stale ring is the map-chrome surface,
+ * because the stale dot is a text rung floored against exactly that surface.
+ *
+ * Measured over a dark tile: the chrome surface as the LIVE ring disappeared
+ * entirely in dark mode — a dark ring on a dark map — while the on-colour
+ * keeps the puck ringed in both modes over both tiles.
+ *
+ * Nothing here is derived. The cone and the halo are `map-marker`'s own
+ * resolved `area` colour, so the puck belongs to the family that already draws
+ * on maps; the dot and its ring are one accent pair; the stale dot and its ring
+ * are one surface pair.
+ */
+export declare function resolveLocationPuckPaint(theme: Theme): LocationPuckPaint;
+/**
+ * The cone's half-width in degrees: the platform's own heading uncertainty,
+ * clamped into the band where a wedge still means something.
+ *
+ * A non-finite or negative reading takes the floor rather than collapsing the
+ * wedge to nothing — "the device told us nothing" is {@link
+ * LocationPuckProps.headingUnknown}, and it draws no cone at all.
+ */
+export declare function coneHalfAngle(headingAccuracy: number | undefined): number;
+/** A heading folded into `[0, 360)`; a non-finite one reads as north. */
+export declare function normalizeHeading(heading: number | undefined): number;
+/**
+ * How far the puck's own box has to turn.
+ *
+ * `compass` is 0 BY CONSTRUCTION: the app has already rotated the map so the
+ * heading is up, and turning the cone as well would apply the rotation twice —
+ * the mirror of the correction `MapCompass` makes for its needle.
+ */
+export declare function puckRotation(mode: LocationPuckMode, heading: number | undefined): number;
+/**
+ * The wedge, as an SVG path, in a `2 * length` square whose centre is the dot.
+ *
+ * Drawn pointing UP (the `-90°` ray) and turned by the caller's own transform,
+ * so the apex is the box's centre and a rotation about that centre is a
+ * rotation about the dot. `MeterRing` makes the same split for the same reason:
+ * `react-native-svg` applies an element transform before the geometry on some
+ * native versions, so the rotation belongs on the host view, never on the path.
+ *
+ * `A` takes `large-arc-flag 0` because the arc is at most
+ * `2 * coneMaxHalfAngle` = 110°, and `sweep-flag 1` because SVG's y axis points
+ * down, so increasing angle is clockwise.
+ */
+export declare function conePath(length: number, halfAngle: number): string;
+/**
+ * The navigating chevron, as SVG polygon points in a `size` square, tip up.
+ *
+ * A chevron rather than an arrow because the notch is what makes the shape read
+ * as a direction at 28px with no stroke weight to spare, and the notch depth is
+ * 0.7 of the height — shallower and it is a triangle, deeper and the two wings
+ * separate.
+ */
+export declare function chevronPoints(size: number): string;
+/**
+ * The square the whole puck occupies: whichever layer reaches furthest.
+ *
+ * Every layer is centred in it, so an app centres this ONE box on the
+ * coordinate and the dot lands on the coordinate — the positioning contract
+ * `map-marker` already publishes ("it positions nothing; centre it on the
+ * point"). The halo is a diameter, the cone reaches `length` from the centre in
+ * one direction but needs the full box to rotate inside.
+ */
+export declare function puckBoxSize(options: {
+    accuracyRadius?: number;
+    coneLength?: number;
+    cone: boolean;
+}): number;
+/**
+ * What a screen reader hears instead of a coloured dot.
+ *
+ * The STATE comes first, because it is the part that is not recoverable by
+ * looking: "your last known location" is the whole difference between a map
+ * that is following you and one that stopped. The heading is added only when
+ * there is one — a bearing the device did not measure must not be spoken any
+ * more than it may be drawn.
+ */
+export declare function describeLocationPuck(options: {
+    state: LocationPuckState;
+    mode: LocationPuckMode;
+    heading?: number;
+    headingUnknown?: boolean;
+    labels?: Partial<Record<LocationPuckState, string>>;
+}): string;
+//# sourceMappingURL=shared.d.ts.map

package/lib/typescript/module/location-puck/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/location-puck/shared.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEnE,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAC;IACZ,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,0FAA0F;IAC1F,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,iBAAiB,CAUxE;AAMD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAIzE;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAGpE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAExF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAYlE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,MAAM,CAUT;AAMD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC;CACrD,GAAG,MAAM,CAMT"}

package/lib/typescript/module/location-puck/types.d.ts

@@ -0,0 +1,77 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+/**
+ * How trustworthy the position under the puck is.
+ *
+ * `locating` is "we are still working it out" — the dot pulses and the halo
+ * breathes, because a still puck over a wrong coordinate reads as a fix.
+ * `located` is a live fix and stands still. `stale` is a position that is no
+ * longer being updated: it goes quiet, loses the accent, and SAYS SO, because
+ * a dimmer dot is not a sentence and a reader who cannot see it has no other
+ * way of learning that the map is showing where you were.
+ */
+export type LocationPuckState = 'locating' | 'located' | 'stale';
+/**
+ * What the map underneath is doing, which is what decides where the cone
+ * points and whether there is a cone at all.
+ *
+ * `following` — the map is north-up and the puck turns inside it.
+ * `compass` — the map turns so the heading is always up, so the cone is drawn
+ *   straight up and the app's own rotation does the rest. Passing the heading
+ *   AND rotating the map would turn the cone twice.
+ * `navigating` — the puck is a chevron on a route. The chevron IS the
+ *   direction, so no cone is drawn beside it.
+ */
+export type LocationPuckMode = 'following' | 'compass' | 'navigating';
+export interface LocationPuckProps {
+    /** Default `located`. */
+    state?: LocationPuckState;
+    /** Default `following`. */
+    mode?: LocationPuckMode;
+    /**
+     * Which way you are facing, in degrees clockwise from north. Turns the cone
+     * in `following`, and the chevron in `navigating`; ignored in `compass`,
+     * where the map itself is what turned.
+     */
+    heading?: number;
+    /**
+     * The platform's own ± uncertainty for {@link heading}, in DEGREES, and the
+     * cone's half-width: the wedge is the uncertainty, drawn. Clamped into
+     * `[coneMinHalfAngle, coneMaxHalfAngle]`, and defaulted to the minimum when
+     * the platform reports nothing.
+     */
+    headingAccuracy?: number;
+    /**
+     * No heading at all — draws NO cone. A guessed cone is worse than none: it
+     * is a confident claim about the one thing the device could not measure.
+     */
+    headingUnknown?: boolean;
+    /**
+     * The accuracy halo's radius in PIXELS. The app computes it from its own map
+     * projection (metres at this latitude and zoom → pixels) and re-renders on
+     * zoom, exactly as it does for `MapAreaCircle` — which is the circle this
+     * draws.
+     *
+     * Without it no halo is drawn: a halo of an invented size is a claim about
+     * precision nobody measured.
+     */
+    accuracyRadius?: number;
+    /** How far the cone reaches, in pixels. Default {@link LOCATION_PUCK_GEOMETRY}`.cone`. */
+    coneLength?: number;
+    /**
+     * The puck's announced name. Defaults to the sentence
+     * {@link describeLocationPuck} builds from the state, the mode and the
+     * heading — a coloured dot says nothing aloud.
+     */
+    accessibilityLabel?: string;
+    /** Replaces the English state words. */
+    stateLabels?: Partial<Record<LocationPuckState, string>>;
+    /**
+     * Force the pulse off regardless of the OS preference. Omitted, the puck
+     * reads the platform's reduced-motion setting and stands still when it is on.
+     */
+    reducedMotion?: boolean;
+    style?: StyleProp<ViewStyle>;
+    /** Parts get `<testID>-halo`, `-cone`, `-dot`, `-chevron`. */
+    testID?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/location-puck/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/location-puck/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,SAAS,GAAG,YAAY,CAAC;AAEtE,MAAM,WAAW,iBAAiB;IAChC,yBAAyB;IACzB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,2BAA2B;IAC3B,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/lib/typescript/module/map-attribution/MapAttribution.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { MapAttributionProps } from './types';
+/**
+ * THE SMALL PRINT, which is not optional: who the map data belongs to, how big
+ * the map is, and when the tiles were last refreshed.
+ *
+ *   shell    `island` by default — the credit has to stay legible over a
+ *            satellite photo, a white street map and everything between, and
+ *            the only way to promise that is not to put it ON the map. The
+ *            island's fill is a surface Bloom owns; the tiles are not.
+ *   scale    `MapScaleBar`, drawn `inline` so the pane is one pane rather than
+ *            two stacked ones
+ *   credit   `caption-2-regular`. With `onPressCredit` it is `Button`'s `link`
+ *            variant at the same step — running text with the library's own
+ *            focus ring and hover underline, rather than a second pressable
+ *            with a ring of its own.
+ *   updated  after a separator, at the same step, one rung quieter
+ *
+ * ── THE CREDIT IS REQUIRED AND NEVER DEFAULTED ──────────────────────────────
+ *
+ * Every other string here has a sensible English default. This one does not,
+ * and that is the point: a component that invented a credit would put a WRONG
+ * attribution on a map, and a wrong attribution is a licence problem rather
+ * than a visual one. The app passes what its provider's licence says, verbatim.
+ *
+ * It reads no clock and knows no units. `updated` and every scale reading
+ * arrive pre-formatted.
+ */
+declare function MapAttributionComponent({ credit, onPressCredit, creditLabel, scales, scaleLabel, updated, variant, accessibilityLabel, style, testID, }: MapAttributionProps): import("react/jsx-runtime").JSX.Element;
+export declare const MapAttribution: React.MemoExoticComponent<typeof MapAttributionComponent>;
+export {};
+//# sourceMappingURL=MapAttribution.d.ts.map

package/lib/typescript/module/map-attribution/MapAttribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapAttribution.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/MapAttribution.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwB,MAAM,OAAO,CAAC;AAU7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,uBAAuB,CAAC,EAC/B,MAAM,EACN,aAAa,EACb,WAAW,EACX,MAAM,EACN,UAAU,EACV,OAAO,EACP,OAAkB,EAClB,kBAA+B,EAC/B,KAAK,EACL,MAAM,GACP,EAAE,mBAAmB,2CAyErB;AAED,eAAO,MAAM,cAAc,2DAAgC,CAAC"}

package/lib/typescript/module/map-attribution/MapAttributionShell.d.ts

@@ -0,0 +1,30 @@
+import React, { type ReactNode } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { MapAttributionVariant } from './types';
+/**
+ * The box the small print sits in — the ONE place the two components in this
+ * family decide what "legible over any tile" means, so they cannot drift apart.
+ *
+ * `island` is `GlassIsland` at the 8 rung: a translucent pane with a hairline
+ * and a shadow, over content Bloom does not own. It is asked for a SURFACE
+ * radius rather than its default capsule, because the small print is a surface
+ * and the pill rung belongs to button-like controls. `inline` renders a plain
+ * `View` with the same padding, for a strip already inside a surface the app
+ * painted — a legend panel, a settings row — where a second pane would be a
+ * second card.
+ *
+ * Internal: not on the barrel. It is the shell, not a component a consumer
+ * should mount around something else.
+ */
+export interface MapAttributionShellProps {
+    variant: MapAttributionVariant;
+    children?: ReactNode;
+    role?: 'group';
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare function MapAttributionShellComponent({ variant, children, role, accessibilityLabel, style, testID, }: MapAttributionShellProps): import("react/jsx-runtime").JSX.Element;
+export declare const MapAttributionShell: React.MemoExoticComponent<typeof MapAttributionShellComponent>;
+export {};
+//# sourceMappingURL=MapAttributionShell.d.ts.map

package/lib/typescript/module/map-attribution/MapAttributionShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapAttributionShell.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/MapAttributionShell.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAQ,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAIpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iBAAS,4BAA4B,CAAC,EACpC,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,kBAAkB,EAClB,KAAK,EACL,MAAM,GACP,EAAE,wBAAwB,2CAuC1B;AAED,eAAO,MAAM,mBAAmB,gEAAqC,CAAC"}

package/lib/typescript/module/map-attribution/MapScaleBar.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { MapScaleBarProps } from './types';
+/**
+ * HOW BIG THE MAP IS: a measured span with a tick at each end, and what that
+ * span is worth.
+ *
+ *   bar      the app's own width in pixels, a 1px rule along the bottom and a
+ *            5px tick rising from each end — the ticks are what make it read as
+ *            a measurement BETWEEN TWO MARKS rather than as an underline
+ *   reading  `caption-2-medium`, at the end of the bar, on the baseline
+ *   two bars  metric over imperial, sharing a left edge, so the eye compares
+ *            them as one instrument rather than reading two
+ *
+ * The rule takes the GRAPHICAL contrast rung and the reading a TEXT one. They
+ * are different jobs: a line has to be seen, a number has to be read, and
+ * flooring the line at text contrast would make the quietest thing on the map
+ * the loudest thing on the strip.
+ *
+ * It converts nothing. Every width and every reading comes from the app,
+ * because the projection does — see `MapScale`.
+ *
+ * The whole thing is one `img` named by `describeScale`: a bar and two ticks
+ * say nothing aloud, and "500 m" on its own is as likely to be a distance to
+ * somewhere as a scale.
+ */
+declare function MapScaleBarComponent({ scales, variant, scaleLabel, accessibilityLabel, style, testID, }: MapScaleBarProps): import("react/jsx-runtime").JSX.Element;
+export declare const MapScaleBar: React.MemoExoticComponent<typeof MapScaleBarComponent>;
+export {};
+//# sourceMappingURL=MapScaleBar.d.ts.map

package/lib/typescript/module/map-attribution/MapScaleBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapScaleBar.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/MapScaleBar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwB,MAAM,OAAO,CAAC;AAQ7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iBAAS,oBAAoB,CAAC,EAC5B,MAAM,EACN,OAAkB,EAClB,UAAU,EACV,kBAAkB,EAClB,KAAK,EACL,MAAM,GACP,EAAE,gBAAgB,2CA+DlB;AAED,eAAO,MAAM,WAAW,wDAA6B,CAAC"}

package/lib/typescript/module/map-attribution/constants.d.ts

@@ -0,0 +1,28 @@
+export interface MapAttributionGeometry {
+    /** The island's radius. The small print is a surface, so it takes a rung of the scale. */
+    radius: number;
+    /** The island's padding. */
+    paddingVertical: number;
+    /** The island's padding, sideways — wider, so short words are not pinched. */
+    paddingHorizontal: number;
+    /** Between the scale, the credit and the date. */
+    gap: number;
+    /** The scale bar's rule. */
+    rule: number;
+    /** The tick at each end of a bar, measured from the rule. */
+    tick: number;
+    /** Between the bar and its reading. */
+    scaleGap: number;
+    /** Between two stacked bars. */
+    scaleStack: number;
+}
+/**
+ * 6 and 10 of padding, and a radius of 8: the strip has to be the smallest
+ * thing on the map and still be a surface rather than a shadow of one.
+ *
+ * The tick is 5 either side of the rule — long enough that the bar's ENDS are
+ * what you read (a scale bar is a measurement between two marks, not a line),
+ * short enough that it does not become a bracket.
+ */
+export declare const MAP_ATTRIBUTION_GEOMETRY: MapAttributionGeometry;
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/module/map-attribution/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/constants.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,sBAAsB;IACrC,0FAA0F;IAC1F,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAC;IACZ,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,sBAStC,CAAC"}

package/lib/typescript/module/map-attribution/index.d.ts

@@ -0,0 +1,8 @@
+export { MapAttribution } from './MapAttribution';
+export { MapScaleBar } from './MapScaleBar';
+export { MAP_ATTRIBUTION_GEOMETRY } from './constants';
+export type { MapAttributionGeometry } from './constants';
+export { describeScale, resolveMapAttributionPaint } from './shared';
+export type { MapAttributionPaint } from './shared';
+export type { MapAttributionProps, MapAttributionVariant, MapScale, MapScaleBarProps, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/map-attribution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AACrE,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,GACjB,MAAM,SAAS,CAAC"}

package/lib/typescript/module/map-attribution/shared.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What the small print paints, and how it reads aloud. Pure, so a gate can walk
+ * every preset x mode without rendering.
+ */
+import { type SurfaceTextPaint } from '../styles/surface-levels';
+import type { Theme } from '../theme/types';
+import type { MapScale } from './types';
+export interface MapAttributionPaint extends SurfaceTextPaint {
+    /** The island's own fill — what every rung here is measured against. */
+    surface: string;
+    /** The scale bar's rule and its end ticks. */
+    rule: string;
+    /** A separator between two readings. */
+    border: string;
+}
+/**
+ * Measured against the ISLAND's fill, not against the page and not against the
+ * map.
+ *
+ * The map is content Bloom does not own — it can be a night satellite tile, a
+ * white street map or a photograph — so no text rung can be floored against it.
+ * The island's rung 1 fill is a surface Bloom DOES own, which is the whole
+ * reason the small print sits on one: over a photo the credit stays legible
+ * because it is not on the photo.
+ *
+ * The rule takes the GRAPHICAL rung (3:1) rather than a text one: a scale bar
+ * is a line, and flooring it at text contrast would make the quietest thing on
+ * the map the loudest thing on the strip.
+ */
+export declare function resolveMapAttributionPaint(theme: Theme): MapAttributionPaint;
+/**
+ * "Scale, 500 m, 1000 ft".
+ *
+ * A bar and two ticks say nothing aloud, and the reading beside them is a
+ * number with no noun — "500 m" on its own is as likely to be a distance to
+ * somewhere as a scale. The word comes first so it is the first thing heard.
+ */
+export declare function describeScale(scales: readonly MapScale[], scaleLabel?: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/lib/typescript/module/map-attribution/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/shared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,KAAK,GAAG,mBAAmB,CAS5E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,EAAE,UAAU,GAAE,MAAgB,GAAG,MAAM,CAI/F"}

package/lib/typescript/module/map-attribution/types.d.ts

@@ -0,0 +1,76 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+/**
+ * One bar of the scale: how WIDE it is on screen, and what that width is worth.
+ *
+ * Both come from the app, because only the app knows its projection — the
+ * width in pixels for a round number of metres at this latitude and zoom, and
+ * the formatted words for that number. Bloom converts nothing and rounds
+ * nothing: a scale bar that guessed its own units would be a measuring
+ * instrument that measures the component rather than the map.
+ */
+export interface MapScale {
+    /** The bar's drawn length, in pixels. */
+    width: number;
+    /** What that length is worth, pre-formatted — "500 m", "1000 ft". */
+    label: string;
+    /** Stable key. Defaults to the index. */
+    id?: string;
+}
+/**
+ * `island` floats the small print over tiles Bloom does not own and gives it
+ * the one material priced for that. `inline` draws the words and nothing else,
+ * for a strip that is already inside a surface the app painted.
+ */
+export type MapAttributionVariant = 'island' | 'inline';
+export interface MapScaleBarProps {
+    /**
+     * One bar, or two — a metric bar and an imperial one, in that order. Two is
+     * the case this takes a list for: they are the same measurement in two
+     * vocabularies and must line up under each other rather than appear as two
+     * separate instruments.
+     */
+    scales: readonly MapScale[];
+    /** Default `island`. */
+    variant?: MapAttributionVariant;
+    /** The word before the readings in the announcement. Default `"Scale"`. */
+    scaleLabel?: string;
+    /** Defaults to `"Scale, 500 m, 1000 ft"`. */
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    /** Parts get `<testID>-bar-<n>`, `<testID>-rule-<n>`. */
+    testID?: string;
+}
+export interface MapAttributionProps {
+    /**
+     * The credit the data's licence requires, as the licence words it. NOT
+     * optional and NOT defaulted: a component that invented a default credit
+     * would put a wrong attribution on a map, which is the one failure in this
+     * family that is a legal problem rather than a visual one.
+     */
+    credit: string;
+    /**
+     * Opens the provider's own attribution page. With it the credit becomes a
+     * link; without it, plain text.
+     */
+    onPressCredit?: () => void;
+    /** The link's announced name. Defaults to `credit`. */
+    creditLabel?: string;
+    /** The scale bar, drawn before the credit. Without it none is drawn. */
+    scales?: readonly MapScale[];
+    /** The word before the readings in the scale's announcement. Default `"Scale"`. */
+    scaleLabel?: string;
+    /**
+     * When the tiles were last refreshed, pre-formatted by the app — "Updated 12
+     * March", "Updated 3 days ago". Never computed here: this component does not
+     * read a clock.
+     */
+    updated?: string;
+    /** Default `island`. */
+    variant?: MapAttributionVariant;
+    /** Names the strip. Default `"Map data"`. */
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    /** Parts get `<testID>-scale`, `-credit`, `-updated`. */
+    testID?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/map-attribution/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/map-attribution/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC5B,wBAAwB;IACxB,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,MAAM,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC7B,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wBAAwB;IACxB,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,6CAA6C;IAC7C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/lib/typescript/module/map-controls/MapCompass.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { MapCompassProps } from './types';
+declare function MapCompassComponent({ heading, onPress, hideAtNorth, disabled, accessibilityLabel, style, testID, }: MapCompassProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const MapCompass: React.MemoExoticComponent<typeof MapCompassComponent>;
+export {};
+//# sourceMappingURL=MapCompass.d.ts.map

package/lib/typescript/module/map-controls/MapCompass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapCompass.d.ts","sourceRoot":"","sources":["../../../../src/map-controls/MapCompass.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAShD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAmC/C,iBAAS,mBAAmB,CAAC,EAC3B,OAAO,EACP,OAAO,EACP,WAAkB,EAClB,QAAgB,EAChB,kBAAkB,EAClB,KAAK,EACL,MAAM,GACP,EAAE,eAAe,kDAqBjB;AAED,eAAO,MAAM,UAAU,uDAA4B,CAAC"}

package/lib/typescript/module/map-controls/MapControls.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import type { MapControlsProps } from './types';
+/**
+ * The chrome that floats over a map — locate, compass, zoom, tilt — as a
+ * column of translucent capsules.
+ *
+ *   island   every group is a `GlassIsland`: rung 1 of the surface ladder at
+ *            the chrome alpha, with the material's own hairline and shadow.
+ *            One capsule per GROUP, so the column reads as separate controls
+ *            rather than as one bar — which is exactly what the island was
+ *            written for.
+ *   control  `ButtonGroupItem` at 44 square. It is Bloom's island-aware
+ *            control: it reads the `material` the island publishes through
+ *            `ControlSurface` and paints flush, with no `variant` written on
+ *            it, and it carries a toggle's `aria-pressed` and native selected
+ *            state in one prop.
+ *   zoom     ONE island, two items, laid out in a column. The island's `style`
+ *            is where that is said; nothing else about it changes.
+ *   stack    44 controls, 8 apart, hugging whichever edge `align` names.
+ *
+ * WHY NOT `FrostedIconButton`: it is one of the three glass materials Bloom
+ * grew independently, and `glass/` exists so there is not a fourth. Two glass
+ * recipes side by side in one stack is the drift the island was written to
+ * end, so the whole stack is one material. A single frosted button over a
+ * photograph is still the right control where there is no island.
+ *
+ * WHAT THIS DOES NOT DO: it never touches a map. Every control is a callback,
+ * every state is a prop, and there is no engine, no projection and no tile
+ * here — the app owns the map and tells the chrome what it is doing.
+ *
+ * The `MapLayerPicker` is not a prop: it is an island of its own, placed in
+ * `children`, so an app can put it above the stack, below it, or somewhere
+ * else entirely without this component growing a placement vocabulary.
+ */
+declare function MapControlsComponent({ onLocate, following, heading, onResetNorth, hideCompassAtNorth, onZoomIn, onZoomOut, canZoomIn, canZoomOut, onTiltChange, tilted, children, align, labels, style, testID, }: MapControlsProps): import("react/jsx-runtime").JSX.Element;
+export declare const MapControls: React.MemoExoticComponent<typeof MapControlsComponent>;
+export {};
+//# sourceMappingURL=MapControls.d.ts.map

package/lib/typescript/module/map-controls/MapControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapControls.d.ts","sourceRoot":"","sources":["../../../../src/map-controls/MapControls.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAC;AAWpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,iBAAS,oBAAoB,CAAC,EAC5B,QAAQ,EACR,SAAS,EACT,OAAO,EACP,YAAY,EACZ,kBAAyB,EACzB,QAAQ,EACR,SAAS,EACT,SAAgB,EAChB,UAAiB,EACjB,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,KAAa,EACb,MAAM,EACN,KAAK,EACL,MAAM,GACP,EAAE,gBAAgB,2CA0FlB;AAED,eAAO,MAAM,WAAW,wDAA6B,CAAC"}

package/lib/typescript/module/map-controls/MapLayerPicker.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { MapLayerPickerProps } from './types';
+/**
+ * What the map is DRAWN as, and what is drawn ON it.
+ *
+ * Two vocabularies in one menu, because they are two questions a reader asks in
+ * the same breath and they answer differently:
+ *
+ *   map types   exactly one — standard, satellite, transit. A
+ *               `DropdownMenuRadioGroup`, so the announced tree is a radio
+ *               group and the chosen one carries `aria-checked`.
+ *   overlays    any number — traffic, bike lanes. `DropdownMenuCheckboxItem`s,
+ *               each its own checkbox.
+ *
+ * Neither is a control this family wrote. The rows, the indicators, the
+ * keyboard handling, the dismissal and the anchoring are `dropdown-menu`'s; the
+ * trigger is a `ButtonGroupItem` composed through `asChild`, which is why it
+ * announces its own expanded state; and the capsule it sits in is the same
+ * `GlassIsland` every other map control sits in, so the picker lands in the
+ * stack as one more island rather than as a different kind of thing.
+ */
+declare function MapLayerPickerComponent({ layers, layerId, onLayerChange, overlays, activeOverlayIds, onOverlayChange, icon, disabled, open, defaultOpen, onOpenChange, labels, style, testID, }: MapLayerPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare const MapLayerPicker: React.MemoExoticComponent<typeof MapLayerPickerComponent>;
+export {};
+//# sourceMappingURL=MapLayerPicker.d.ts.map

package/lib/typescript/module/map-controls/MapLayerPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapLayerPicker.d.ts","sourceRoot":"","sources":["../../../../src/map-controls/MapLayerPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAC;AAgBpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,iBAAS,uBAAuB,CAAC,EAC/B,MAAM,EACN,OAAO,EACP,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,IAAkB,EAClB,QAAgB,EAChB,IAAI,EACJ,WAAW,EACX,YAAY,EACZ,MAAM,EACN,KAAK,EACL,MAAM,GACP,EAAE,mBAAmB,2CA2DrB;AAED,eAAO,MAAM,cAAc,2DAAgC,CAAC"}

package/lib/typescript/module/map-controls/constants.d.ts

@@ -0,0 +1,28 @@
+export interface MapControlsGeometry {
+    /** A control's square target. */
+    control: number;
+    /** Between two islands in the stack. */
+    gap: number;
+    /**
+     * How close to north the map has to be for the compass to call itself
+     * pointed north and step out of the way.
+     */
+    northTolerance: number;
+}
+/**
+ * 44 is the target, not the 34 the button group's `medium` rung draws.
+ *
+ * A group rung is sized for a toolbar standing beside other chrome, where the
+ * row as a whole is the target a finger aims at. A map control is a LONE
+ * circle over a moving map with a finger already on the glass, and 34 is under
+ * every platform's minimum. The item takes the size through its own `style`,
+ * which is the override `ButtonGroupItem` publishes — nothing about its fill,
+ * its hover, its press or its focus ring changes.
+ */
+export declare const MAP_CONTROLS_GEOMETRY: MapControlsGeometry;
+/** The square every control in the stack takes. */
+export declare const MAP_CONTROL_BOX: {
+    readonly width: number;
+    readonly height: number;
+};
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/module/map-controls/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/map-controls/constants.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAInC,CAAC;AAEF,mDAAmD;AACnD,eAAO,MAAM,eAAe;;;CAGlB,CAAC"}

package/lib/typescript/module/map-controls/context.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The map's heading, in degrees clockwise from north, for the compass needle.
+ *
+ * WHY A CONTEXT FOR ONE NUMBER: `ButtonGroupItem` takes its glyph as a
+ * COMPONENT (`leadingIcon={RiCompass3Line}`), and a needle has to rotate. A
+ * component built from the heading would be a new component TYPE on every
+ * degree, so React would unmount and remount the SVG on every frame of a map
+ * rotation. A module-scope component reading the heading from here keeps one
+ * identity for the life of the control, and only the needle re-renders.
+ */
+export declare const MapHeadingContext: import("react").Context<number>;
+//# sourceMappingURL=context.d.ts.map

package/lib/typescript/module/map-controls/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/map-controls/context.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,iCAAmB,CAAC"}

package/lib/typescript/module/map-controls/index.d.ts

@@ -0,0 +1,7 @@
+export { MapControls } from './MapControls';
+export { MapCompass } from './MapCompass';
+export { MapLayerPicker } from './MapLayerPicker';
+export { MAP_CONTROL_BOX, MAP_CONTROLS_GEOMETRY } from './constants';
+export type { MapControlsGeometry } from './constants';
+export type { MapCompassProps, MapControlsAlign, MapControlsLabels, MapControlsProps, MapLayerOption, MapLayerPickerLabels, MapLayerPickerProps, MapOverlayOption, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/map-controls/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/map-controls/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACrE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}