@peasant-labs/fairtrade 0.0.2 → 0.0.4

package/dist/lib/types/Intensity.d.ts

@@ -4,11 +4,11 @@ export function clampLevel(level: any): number;
  * coverage ratio (recorded / total) → ramp level. 0 / unknown = none; ≥ 0.9
  * reads as fully covered. mirrors peasant's traceabilityLevel quantiles.
  */
-export function coverageLevel(recorded: any, total: any): 0 | 4 | 1 | 2 | 3;
+export function coverageLevel(recorded: any, total: any): 0 | 1 | 2 | 4 | 3;
 /** density (0..1) → ramp level for the bottom-edge effort bar. */
-export function effortLevel(density: any): 0 | 4 | 1 | 2 | 3;
+export function effortLevel(density: any): 0 | 1 | 2 | 4 | 3;
 /** generic value-vs-max quantization (heatmap cells, sparklines). */
-export function quantize(value: any, max: any): 0 | 4 | 1 | 2 | 3;
+export function quantize(value: any, max: any): 0 | 1 | 2 | 4 | 3;
 /** loc → node size class. small files are compact; large ones get real estate. */
 export function locSize(loc: any): "sm" | "md" | "lg" | "xs" | "xl";
 export function IntensitySwatch({ level, accent, size, label, className, ...rest }: {

package/dist/lib/types/MapCanvas.d.ts

@@ -7,6 +7,12 @@
  * @property {number} [coverage=0]             0..4 monochrome coverage ramp (the FILL)
  * @property {string} [parent]                 parent id (forms the tree)
  * @property {number} [violations=0]           violation count — a clay badge
+ * @property {number} [layer]                  server-assigned row (0 = top row); when
+ *   present, positions this node's ROW instead of tree depth (peasant/codegraph's
+ *   deterministic layer/order contract). Falls back to tree depth when absent.
+ * @property {number} [order]                  server-assigned stable sort key within a
+ *   layer; when present, orders siblings/row-mates instead of input-array position.
+ *   Falls back to input order when absent.
  */
 /**
  * @typedef {Object} MapEdge
@@ -27,21 +33,35 @@
  * @param {Object} props
  * @param {{nodes: MapNode[], edges?: MapEdge[]}} [props.data]   the graph
  * @param {'overview'|'folders'|'files'} [props.grain='folders'] initial semantic zoom
- * @param {string} [props.selectedId]                            initial selection
+ * @param {Iterable<string>} [props.expandedIds]                 expanded node ids
+ * @param {string|null} [props.selectedId]                       selected node id
+ * @param {Iterable<string>} [props.highlightedIds]              host hover/relay ids
+ * @param {Record<string,'new'|'removed'>} [props.nodeDeltas]    per-node review deltas
+ * @param {Record<string,'new'|'removed'>} [props.edgeDeltas]    per-edge review deltas
  * @param {(id:string|null, node:MapNode|null)=>void} [props.onSelect]  selection cb
- * @param {number} [props.height=520]                            canvas height (px)
+ * @param {(grain:'overview'|'folders'|'files')=>void} [props.onGrainChange]
+ * @param {(ids:string[])=>void} [props.onExpandedIdsChange]
+ * @param {(id:string)=>void} [props.onExpand]
+ * @param {number|string} [props.height=520]                     canvas height
  * @param {string} [props.ariaLabel='code map']                  application label
  * @param {string} [props.className]                             extra container class
  */
-export default function MapCanvas({ data, grain: initialGrain, selectedId: initialSelected, onSelect, height, ariaLabel, className, }: {
+export default function MapCanvas({ data, grain: grainProp, expandedIds, selectedId: selectedIdProp, highlightedIds, nodeDeltas, edgeDeltas, onSelect, onGrainChange, onExpandedIdsChange, onExpand, height, ariaLabel, className, }: {
     data?: {
         nodes: MapNode[];
         edges?: MapEdge[];
     };
     grain?: "overview" | "folders" | "files";
-    selectedId?: string;
+    expandedIds?: Iterable<string>;
+    selectedId?: string | null;
+    highlightedIds?: Iterable<string>;
+    nodeDeltas?: Record<string, "new" | "removed">;
+    edgeDeltas?: Record<string, "new" | "removed">;
     onSelect?: (id: string | null, node: MapNode | null) => void;
-    height?: number;
+    onGrainChange?: (grain: "overview" | "folders" | "files") => void;
+    onExpandedIdsChange?: (ids: string[]) => void;
+    onExpand?: (id: string) => void;
+    height?: number | string;
     ariaLabel?: string;
     className?: string;
 }): any;
@@ -74,6 +94,18 @@ export type MapNode = {
      * violation count — a clay badge
      */
     violations?: number;
+    /**
+     * server-assigned row (0 = top row); when
+     * present, positions this node's ROW instead of tree depth (peasant/codegraph's
+     * deterministic layer/order contract). Falls back to tree depth when absent.
+     */
+    layer?: number;
+    /**
+     * server-assigned stable sort key within a
+     * layer; when present, orders siblings/row-mates instead of input-array position.
+     * Falls back to input order when absent.
+     */
+    order?: number;
 };
 export type MapEdge = {
     from: string;

package/dist/lib/types/RoleRoster.d.ts

@@ -43,13 +43,24 @@ export function ConfirmInline({ label, confirmLabel, icon, onConfirm, busy, disa
  * @param {(member: RosterMember) => (void | Promise<void>)} [props.onRemove]  fired when a row's remove is confirmed
  * @param {string} [props.title='members']         section header label (lowercase chrome)
  * @param {string[]} [props.roles]                 selectable roles (default member/contributor/guest; owner is never offered)
+ * @param {boolean} [props.canManage=true]         whether the CURRENT VIEWER may edit roles / remove members at
+ *   all (distinct from `member.owner`, which locks one specific ROW regardless of viewer). When `false`, every
+ *   non-owner row's role renders as plain read-only text (no select) and its remove action is hidden entirely
+ *   -- e.g. a non-owner viewing a roster they can't manage. Defaults to `true` (the prior, only behaviour) so
+ *   existing callers are unaffected.
+ * @param {React.ReactNode} [props.filterSlot]     an optional row rendered INSIDE the roster's own bordered
+ *   box, directly under the header and before the member list (e.g. a "show: [org ▾]" list filter) -- lets a
+ *   consumer add a filter/toolbar control that reads as part of THIS box, not a separate section floating
+ *   above it. Undefined by default, so existing callers render exactly as before.
  */
-export default function RoleRoster({ members, onRole, onRemove, title, roles, }: {
+export default function RoleRoster({ members, onRole, onRemove, title, roles, canManage, filterSlot, }: {
     members: RosterMember[];
     onRole?: (member: RosterMember, role: string) => void;
     onRemove?: (member: RosterMember) => (void | Promise<void>);
     title?: string;
     roles?: string[];
+    canManage?: boolean;
+    filterSlot?: React.ReactNode;
 }): any;
 /**
  * A clay-bordered section wrapping destructive actions (e.g. "delete collective"). Fronted by a

package/dist/lib/types/analytics/ChartCard.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {Object} props
+ * @param {string} props.title Card heading (lowercase chrome by convention).
+ * @param {import('react').ComponentType<{ className?: string, 'aria-hidden'?: boolean | 'true' | 'false' }>} [props.icon]
+ *   Lucide icon component rendered inline before the title.
+ * @param {import('react').ReactNode} [props.subtitle] One-line description under the title.
+ * @param {import('react').ReactNode} [props.aside] Right-aligned head slot (summary figure or control).
+ * @param {import('react').ReactNode} props.children Card body (the chart).
+ * @param {string} [props.className]
+ */
+export default function ChartCard({ title, icon: Icon, subtitle, aside, children, className }: {
+    title: string;
+    icon?: any;
+    subtitle?: any;
+    aside?: any;
+    children: any;
+    className?: string;
+}): any;

package/dist/lib/types/analytics/ContributorTable.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {Object} props
+ * @param {ContributorBreakdown[]} props.rows Pre-sorted rollup rows (sessions desc).
+ * @param {(row: ContributorBreakdown) => import('react').ReactNode} [props.renderContributor]
+ *   Host-owned renderer for the contributor cell. Defaults to an
+ *   initial-letter avatar + the raw id.
+ * @param {number} [props.limit] Cap the number of rows shown; omit for all.
+ * @param {string} [props.className]
+ */
+export default function ContributorTable({ rows, renderContributor, limit, className }: {
+    rows: ContributorBreakdown[];
+    renderContributor?: (row: ContributorBreakdown) => any;
+    limit?: number;
+    className?: string;
+}): any;
+export type ContributorBreakdown = import("./types.js").ContributorBreakdown;

package/dist/lib/types/analytics/ProjectOverview.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @param {Object} props
+ * @param {AnalyticsOverviewPayload} props.payload Cooked data payload — raw
+ *   `sessions` (the surface computes the metrics) or a pre-computed
+ *   `analytics` bundle; `analytics` wins if both are given.
+ * @param {string} [props.title] Heading above the grid. Omit for a chrome-less embed.
+ * @param {import('react').ReactNode} [props.subtitle] Sub-heading under the
+ *   title; defaults to an auto-generated project/contributor/session summary.
+ * @param {ProjectOverviewSections} [props.sections] Host-level show/hide per
+ *   section. Unset keys default to ON; a host-hidden section cannot be
+ *   re-enabled by the built-in toggle.
+ * @param {boolean} [props.showSectionToggle] Show the built-in visible-section
+ *   chip row. Default true.
+ * @param {number} [props.contributorLimit] Cap rows in the contributor table.
+ * @param {(row: ContributorBreakdown) => import('react').ReactNode} [props.renderContributor]
+ *   Host-owned renderer for the contributor cell (name/avatar/link).
+ * @param {number} [props.chartHeight] Height (px) of each chart's plotting
+ *   area. Default 200.
+ * @param {import('react').ReactNode} [props.footnote] Optional prose rendered
+ *   at the end of the scroll region (`.gan-foot`) — page-level commentary the
+ *   host wants to travel with the dashboard.
+ * @param {string} [props.className]
+ */
+export default function ProjectOverview({ payload, title, subtitle, sections, showSectionToggle, contributorLimit, renderContributor, chartHeight, footnote, className, }: {
+    payload: AnalyticsOverviewPayload;
+    title?: string;
+    subtitle?: any;
+    sections?: ProjectOverviewSections;
+    showSectionToggle?: boolean;
+    contributorLimit?: number;
+    renderContributor?: (row: ContributorBreakdown) => any;
+    chartHeight?: number;
+    footnote?: any;
+    className?: string;
+}): any;
+export type AnalyticsOverviewPayload = import("./types.js").AnalyticsOverviewPayload;
+export type ProjectOverviewSectionKey = import("./types.js").ProjectOverviewSectionKey;
+export type ProjectOverviewSections = import("./types.js").ProjectOverviewSections;
+export type ContributorBreakdown = import("./types.js").ContributorBreakdown;
+export type ProjectAnalytics = import("./types.js").ProjectAnalytics;

package/dist/lib/types/analytics/format.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Compact token count: 1234 → "1.2k", 62_000 → "62k", 1_234_567 → "1.23M".
+ * @param {number | null | undefined} n
+ * @returns {string}
+ */
+export function formatTokens(n: number | null | undefined): string;
+/**
+ * Round a number to at most 1 decimal place, dropping a trailing ".0".
+ * @param {number | null | undefined} n
+ * @returns {string}
+ */
+export function formatNumber(n: number | null | undefined): string;
+/**
+ * Percentage from a [0,1] rate: 0.4231 → "42%".
+ * @param {number | null | undefined} rate
+ * @returns {string}
+ */
+export function formatRate(rate: number | null | undefined): string;
+/**
+ * Minutes → human duration: 90 → "1h 30m", 45 → "45m".
+ * @param {number | null | undefined} mins
+ * @returns {string}
+ */
+export function formatDuration(mins: number | null | undefined): string;
+/**
+ * Shorten a `YYYY-MM-DD` week key to `MM-DD` for compact axis ticks.
+ * @param {string} week
+ * @returns {string}
+ */
+export function shortWeek(week: string): string;
+/**
+ * Format a median·p90 pair of plain numbers with MATCHED precision (the
+ * identical-precision rule: "8.0 · 19.2", never "8 · 19.2"; two integers stay
+ * "12 · 27"). Nulls render "—" individually.
+ * @param {number | null | undefined} a
+ * @param {number | null | undefined} b
+ * @returns {[string, string]}
+ */
+export function formatNumberPair(a: number | null | undefined, b: number | null | undefined): [string, string];
+/**
+ * Format a median·p90 pair of token counts with a SHARED unit and matched
+ * precision ("10.5k · 23.0k", "62k · 106k"). Unit is picked from the larger
+ * value; nulls render "—" individually.
+ * @param {number | null | undefined} a
+ * @param {number | null | undefined} b
+ * @returns {[string, string]}
+ */
+export function formatTokenPair(a: number | null | undefined, b: number | null | undefined): [string, string];

package/dist/lib/types/analytics/index.d.ts

@@ -0,0 +1,24 @@
+export { default as ProjectOverview } from "./ProjectOverview.jsx";
+export { default as ChartCard } from "./ChartCard.jsx";
+export { default as ContributorTable } from "./ContributorTable.jsx";
+export type AnalyticsSessionOutcome = import("./types.js").AnalyticsSessionOutcome;
+export type ProjectOverviewSectionKey = import("./types.js").ProjectOverviewSectionKey;
+export type AnalyticsSessionRecord = import("./types.js").AnalyticsSessionRecord;
+export type AnalyticsOverviewPayload = import("./types.js").AnalyticsOverviewPayload;
+export type ProjectOverviewSections = import("./types.js").ProjectOverviewSections;
+export type WeekCount = import("./types.js").WeekCount;
+export type WeekContributors = import("./types.js").WeekContributors;
+export type ReturningContributorRate = import("./types.js").ReturningContributorRate;
+export type LongestStreak = import("./types.js").LongestStreak;
+export type WeekNewContributors = import("./types.js").WeekNewContributors;
+export type SessionToCommitRate = import("./types.js").SessionToCommitRate;
+export type WeekAvgDuration = import("./types.js").WeekAvgDuration;
+export type OutcomeDistribution = import("./types.js").OutcomeDistribution;
+export type MedianP90 = import("./types.js").MedianP90;
+export type SessionStats = import("./types.js").SessionStats;
+export type ContributorBreakdown = import("./types.js").ContributorBreakdown;
+export type ProjectAnalytics = import("./types.js").ProjectAnalytics;
+export { computeProjectAnalytics, sessionHasCommit, sessionsPerWeek, weeklyActiveContributors, returningContributorRate, longestStreak, newContributorVelocity, sessionToCommitRate, avgDurationPerActiveWeek, outcomeDistribution, resolvedRate, sessionStats, perContributorBreakdown } from "./metrics.js";
+export { median, percentile, medianAndP90 } from "./stats.js";
+export { weekKey, dayKey, daysBetween, parseTime, isoDate } from "./time.js";
+export { ANALYTICS_SESSION_OUTCOMES, PROJECT_OVERVIEW_SECTION_DEFS, PROJECT_OVERVIEW_SECTION_KEYS } from "./types.js";

package/dist/lib/types/analytics/metrics.d.ts

@@ -0,0 +1,130 @@
+/** @typedef {import('./types.js').AnalyticsSessionRecord} AnalyticsSessionRecord */
+/** @typedef {import('./types.js').WeekCount} WeekCount */
+/** @typedef {import('./types.js').WeekContributors} WeekContributors */
+/** @typedef {import('./types.js').ReturningContributorRate} ReturningContributorRate */
+/** @typedef {import('./types.js').LongestStreak} LongestStreak */
+/** @typedef {import('./types.js').WeekNewContributors} WeekNewContributors */
+/** @typedef {import('./types.js').SessionToCommitRate} SessionToCommitRate */
+/** @typedef {import('./types.js').WeekAvgDuration} WeekAvgDuration */
+/** @typedef {import('./types.js').OutcomeDistribution} OutcomeDistribution */
+/** @typedef {import('./types.js').SessionStats} SessionStats */
+/** @typedef {import('./types.js').ContributorBreakdown} ContributorBreakdown */
+/** @typedef {import('./types.js').ProjectAnalytics} ProjectAnalytics */
+/**
+ * Does this session have at least one linked commit? `commitCount > 0` wins
+ * when present, else the `hasCommit` flag.
+ * @param {AnalyticsSessionRecord} s
+ * @returns {boolean}
+ */
+export function sessionHasCommit(s: AnalyticsSessionRecord): boolean;
+/**
+ * sessionsPerWeek — number of sessions per ISO week, sorted ascending by week.
+ * Weeks with no sessions are omitted (callers can densify if they want a gap-
+ * free axis). Sessions with an unparseable `startTime` are dropped.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {WeekCount[]}
+ */
+export function sessionsPerWeek(sessions: AnalyticsSessionRecord[]): WeekCount[];
+/**
+ * weeklyActiveContributors — distinct contributor ids active in each ISO week,
+ * sorted ascending by week. The host's `contributorId` is treated as an opaque
+ * key; empty ids are ignored.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {WeekContributors[]}
+ */
+export function weeklyActiveContributors(sessions: AnalyticsSessionRecord[]): WeekContributors[];
+/**
+ * returningContributorRate — fraction of contributors who were active in two
+ * or more distinct ISO weeks. A single-week contributor is "new/one-off"; a
+ * multi-week contributor is "returning".
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {ReturningContributorRate}
+ */
+export function returningContributorRate(sessions: AnalyticsSessionRecord[]): ReturningContributorRate;
+/**
+ * longestStreak — the longest run of consecutive active ISO weeks across all
+ * sessions (project-wide, not per contributor). "Consecutive" means each active
+ * week's Monday is exactly 7 days after the previous active week's Monday.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {LongestStreak}
+ */
+export function longestStreak(sessions: AnalyticsSessionRecord[]): LongestStreak;
+/**
+ * newContributorVelocity — count of contributors making their first-ever
+ * appearance in each ISO week, sorted ascending. A contributor is counted once,
+ * in the week of their earliest session. Useful as an acquisition / growth
+ * signal for a project or collective.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {WeekNewContributors[]}
+ */
+export function newContributorVelocity(sessions: AnalyticsSessionRecord[]): WeekNewContributors[];
+/**
+ * sessionToCommitRate — fraction of sessions that produced at least one commit.
+ * Uses `commitCount > 0` when present, else the `hasCommit` flag. A session
+ * with neither set counts as "no commit".
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {SessionToCommitRate}
+ */
+export function sessionToCommitRate(sessions: AnalyticsSessionRecord[]): SessionToCommitRate;
+/**
+ * avgDurationPerActiveWeek — mean session duration (minutes) for each ISO week
+ * that had at least one session, sorted ascending. Inactive weeks are omitted
+ * (hence "per ACTIVE week"). Non-finite durations are ignored.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {WeekAvgDuration[]}
+ */
+export function avgDurationPerActiveWeek(sessions: AnalyticsSessionRecord[]): WeekAvgDuration[];
+/**
+ * outcomeDistribution — counts of sessions per outcome. Sessions with no
+ * outcome are bucketed under `unknown`, so the four buckets always sum to
+ * `total`.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {OutcomeDistribution}
+ */
+export function outcomeDistribution(sessions: AnalyticsSessionRecord[]): OutcomeDistribution;
+/**
+ * perContributorBreakdown — one rolled-up row per contributor, sorted by
+ * session count descending (ties broken by contributor id). Powers the
+ * contributor table in `ProjectOverview`. Sessions with an empty
+ * `contributorId` are skipped.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {ContributorBreakdown[]}
+ */
+export function perContributorBreakdown(sessions: AnalyticsSessionRecord[]): ContributorBreakdown[];
+/**
+ * resolvedRate — the share of a contributor's KNOWN-outcome sessions that
+ * resolved. Unknown-outcome sessions are excluded from the denominator (an
+ * unrecorded outcome is not a non-resolution); `null` when no session has a
+ * known outcome, so callers can render a placeholder instead of a false 0%.
+ * @param {OutcomeDistribution} outcomes
+ * @returns {number | null}
+ */
+export function resolvedRate(outcomes: OutcomeDistribution): number | null;
+/**
+ * sessionStats — median + p90 of the four core numeric session fields across
+ * the input. A convenience wrapper around `medianAndP90` for the "typical vs.
+ * tail" card in `ProjectOverview`.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {SessionStats}
+ */
+export function sessionStats(sessions: AnalyticsSessionRecord[]): SessionStats;
+/**
+ * computeProjectAnalytics — run every metric over a session list and assemble
+ * the `ProjectAnalytics` bundle. Pure: no React, no I/O. This is what
+ * `ProjectOverview` calls internally when handed raw records.
+ * @param {AnalyticsSessionRecord[]} sessions
+ * @returns {ProjectAnalytics}
+ */
+export function computeProjectAnalytics(sessions: AnalyticsSessionRecord[]): ProjectAnalytics;
+export type AnalyticsSessionRecord = import("./types.js").AnalyticsSessionRecord;
+export type WeekCount = import("./types.js").WeekCount;
+export type WeekContributors = import("./types.js").WeekContributors;
+export type ReturningContributorRate = import("./types.js").ReturningContributorRate;
+export type LongestStreak = import("./types.js").LongestStreak;
+export type WeekNewContributors = import("./types.js").WeekNewContributors;
+export type SessionToCommitRate = import("./types.js").SessionToCommitRate;
+export type WeekAvgDuration = import("./types.js").WeekAvgDuration;
+export type OutcomeDistribution = import("./types.js").OutcomeDistribution;
+export type SessionStats = import("./types.js").SessionStats;
+export type ContributorBreakdown = import("./types.js").ContributorBreakdown;
+export type ProjectAnalytics = import("./types.js").ProjectAnalytics;

package/dist/lib/types/analytics/stats.d.ts

@@ -0,0 +1,23 @@
+/** @typedef {import('./types.js').MedianP90} MedianP90 */
+/**
+ * Linear-interpolated percentile over a numeric array. `p` is in [0, 1].
+ * Non-finite values are dropped first. Returns `null` for an empty input.
+ * @param {number[]} values
+ * @param {number} p
+ * @returns {number | null}
+ */
+export function percentile(values: number[], p: number): number | null;
+/**
+ * Median of a numeric array (50th percentile). `null` for an empty input.
+ * @param {number[]} values
+ * @returns {number | null}
+ */
+export function median(values: number[]): number | null;
+/**
+ * Compute the median and p90 of a distribution in a single pass-pair. Useful
+ * for "typical vs. tail" framing (e.g. duration, tokens) per metric.
+ * @param {number[]} values
+ * @returns {MedianP90}
+ */
+export function medianAndP90(values: number[]): MedianP90;
+export type MedianP90 = import("./types.js").MedianP90;

package/dist/lib/types/analytics/time.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Parse an ISO-8601 string into epoch milliseconds, or `null` if invalid.
+ * @param {string} iso
+ * @returns {number | null}
+ */
+export function parseTime(iso: string): number | null;
+/**
+ * The UTC Monday-of-week date key (`YYYY-MM-DD`) for a given ISO timestamp.
+ * Returns `null` for unparseable input. ISO weeks start on Monday.
+ * @param {string} iso
+ * @returns {string | null}
+ */
+export function weekKey(iso: string): string | null;
+/**
+ * The UTC day key (`YYYY-MM-DD`) for a given ISO timestamp, or `null`.
+ * @param {string} iso
+ * @returns {string | null}
+ */
+export function dayKey(iso: string): string | null;
+/**
+ * Format a Date as a UTC `YYYY-MM-DD` string.
+ * @param {Date} d
+ * @returns {string}
+ */
+export function isoDate(d: Date): string;
+/**
+ * Number of whole days between two `YYYY-MM-DD` date keys (b - a).
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function daysBetween(a: string, b: string): number;