npm - @newtonedev/components - Versions diffs - 0.1.11 → 0.1.13 - Mend

@newtonedev/components 0.1.11 → 0.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (150) hide show

package/src/fonts/SelfHostedFontLoader.tsx DELETED Viewed

@@ -1,44 +0,0 @@
-import { useEffect, useRef } from 'react';
-interface SelfHostedFontLoaderProps {
-  /** Raw @font-face CSS string from the theme API. */
-  readonly fontFaceCss: string;
-}
-/**
- * Injects self-hosted @font-face CSS into <head> via a <style> tag.
- * Used instead of GoogleFontLoader when self-hosted font CSS is available.
- *
- * Uses imperative DOM manipulation because react-native-web's View
- * cannot render <style> elements.
- */
-export function SelfHostedFontLoader({ fontFaceCss }: SelfHostedFontLoaderProps) {
-  const styleRef = useRef<HTMLStyleElement | null>(null);
-  useEffect(() => {
-    if (typeof document === 'undefined') return;
-    // Clean up previous style
-    if (styleRef.current) {
-      styleRef.current.remove();
-      styleRef.current = null;
-    }
-    if (!fontFaceCss) return;
-    const style = document.createElement('style');
-    style.setAttribute('data-newtone-fonts', 'self-hosted');
-    style.textContent = fontFaceCss;
-    document.head.appendChild(style);
-    styleRef.current = style;
-    return () => {
-      if (styleRef.current) {
-        styleRef.current.remove();
-        styleRef.current = null;
-      }
-    };
-  }, [fontFaceCss]);
-  return null;
-}

package/src/fonts/buildGoogleFontsUrl.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- // Re-export from @newtonedev/fonts (canonical source)
2	- export { buildGoogleFontsUrl } from '@newtonedev/fonts';

package/src/fonts/measureFont.ts DELETED Viewed

@@ -1,55 +0,0 @@
-/**
- * Reference string for character width measurement.
- * Covers uppercase, lowercase, digits, and a space — 63 characters total.
- */
-const REF_STRING =
-  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 ';
-/** Race a promise against a timeout. Resolves with fallback if the promise doesn't settle in time. */
-function withTimeout<T>(promise: Promise<T>, ms: number, fallback: T): Promise<T> {
-  return Promise.race([
-    promise,
-    new Promise<T>((resolve) => setTimeout(() => resolve(fallback), ms)),
-  ]);
-}
-/**
- * Measure the average character width ratio for a font using the Canvas API.
- *
- * Waits for the font to load via `document.fonts.load()` before measuring,
- * with a 3-second timeout to prevent hangs when fonts fail to load silently.
- * Falls back to 0.55 if the browser context is unavailable, the font fails
- * to load, or canvas is not supported.
- *
- * The returned ratio represents `avgCharWidth / fontSize`. Multiply by a
- * desired fontSize to estimate character widths for that font.
- *
- * @param fontFamily - Font family name, e.g. "Inter" or "system-ui"
- * @param fontWeight - CSS font-weight number, e.g. 400
- * @param fallback   - CSS fallback stack, e.g. "sans-serif"
- * @param fontSize   - Reference font size in px (default 16)
- * @returns Average character width ratio, e.g. 0.52 for Inter
- */
-export async function measureAvgCharWidth(
-  fontFamily: string,
-  fontWeight: number,
-  fallback: string,
-  fontSize = 16,
-): Promise<number> {
-  if (typeof document === 'undefined') return 0.55;
-  try {
-    await withTimeout(
-      document.fonts.load(`${fontWeight} ${fontSize}px "${fontFamily}"`),
-      3000,
-      [] as FontFace[],
-    );
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    if (!ctx) return 0.55;
-    ctx.font = `${fontWeight} ${fontSize}px "${fontFamily}", ${fallback}`;
-    const ratio = ctx.measureText(REF_STRING).width / REF_STRING.length / fontSize;
-    return Math.round(ratio * 1000) / 1000;
-  } catch {
-    return 0.55;
-  }
-}

package/src/fonts/reportQueue.ts DELETED Viewed

@@ -1,54 +0,0 @@
-import type { ObserverPayload } from '@newtonedev/fonts';
-/**
- * Module-level batch queue for typography observations (Layer 3 reporting).
- *
- * Lives outside React's component lifecycle so it survives re-renders.
- * Observations are enqueued immediately and flushed in a single batch after
- * a 2s debounce — minimising network requests and allowing coalescence.
- *
- * Usage: call `enqueueObservation(endpoint, payload)` from responsive Text
- * instances. Set `reportingEndpoint` on `NewtoneProvider` to opt in.
- */
-interface QueuedObservation {
-  readonly endpoint: string;
-  readonly payload: ObserverPayload;
-}
-const queue: QueuedObservation[] = [];
-let flushTimer: ReturnType<typeof setTimeout> | undefined;
-function flush(): void {
-  if (queue.length === 0) return;
-  // Group by endpoint so a page with multiple endpoints gets one request each
-  const byEndpoint = new Map<string, ObserverPayload[]>();
-  for (const item of queue) {
-    const group = byEndpoint.get(item.endpoint) ?? [];
-    group.push(item.payload);
-    byEndpoint.set(item.endpoint, group);
-  }
-  queue.length = 0;
-  for (const [endpoint, observations] of byEndpoint) {
-    // Fire-and-forget — reporting failures are silent and never affect the UI
-    fetch(endpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ observations }),
-      // keepalive: true allows the request to outlive the page
-      keepalive: true,
-    }).catch(() => {});
-  }
-}
-/**
- * Enqueue a typography observation for batch reporting.
- * Resets the 2s debounce timer on each call.
- */
-export function enqueueObservation(endpoint: string, payload: ObserverPayload): void {
-  queue.push({ endpoint, payload });
-  if (flushTimer !== undefined) clearTimeout(flushTimer);
-  flushTimer = setTimeout(flush, 2000);
-}

package/src/fonts/useLocalCalibration.ts DELETED Viewed

@@ -1,97 +0,0 @@
-import { useState, useEffect } from 'react';
-import { measureAvgCharWidth } from './measureFont';
-const STORAGE_KEY = 'newtone:font-metrics:v1';
-const TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-interface CacheEntry {
-  readonly ratio: number;
-  readonly measuredAt: number;
-}
-type FontMetricsCache = Record<string, CacheEntry>;
-function readCache(): FontMetricsCache {
-  if (typeof localStorage === 'undefined') return {};
-  try {
-    const raw = localStorage.getItem(STORAGE_KEY);
-    return raw ? (JSON.parse(raw) as FontMetricsCache) : {};
-  } catch {
-    return {};
-  }
-}
-function writeCache(cache: FontMetricsCache): void {
-  if (typeof localStorage === 'undefined') return;
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(cache));
-  } catch {
-    // Ignore write errors (quota exceeded, private browsing)
-  }
-}
-function cacheKey(fontFamily: string, fontWeight: number): string {
-  return `${fontFamily}:${fontWeight}`;
-}
-/**
- * Returns the avgCharWidth ratio for a font, using a device-local measurement
- * cached in localStorage (Layer 2 calibration).
- *
- * Resolution order:
- * 1. localStorage cache (if fresh, < 7 days old)
- * 2. `baseCalibration` (Layer 1 — editor-time canvas measurement from theme config)
- * 3. 0.55 (fallback constant)
- *
- * On mount, measures the font if the cache is stale or absent, then updates
- * localStorage and triggers a re-render with the device-accurate ratio.
- *
- * @param fontFamily    - CSS font family name, e.g. "Inter"
- * @param fontWeight    - CSS font-weight number, e.g. 400
- * @param fallback      - CSS fallback stack, e.g. "sans-serif"
- * @param baseCalibration - Layer 1 ratio from `themeConfig.typography.calibrations`
- */
-export function useLocalCalibration(
-  fontFamily: string,
-  fontWeight: number,
-  fallback: string,
-  baseCalibration?: number,
-): number {
-  const key = cacheKey(fontFamily, fontWeight);
-  // Initialise synchronously from cache so the first render uses a calibrated ratio
-  const [ratio, setRatio] = useState<number>(() => {
-    const cache = readCache();
-    const entry = cache[key];
-    if (entry && Date.now() - entry.measuredAt < TTL_MS) {
-      return entry.ratio;
-    }
-    return baseCalibration ?? 0.55;
-  });
-  useEffect(() => {
-    const cache = readCache();
-    const entry = cache[key];
-    if (entry && Date.now() - entry.measuredAt < TTL_MS) {
-      // Cache is fresh — no re-measurement needed
-      if (entry.ratio !== ratio) setRatio(entry.ratio);
-      return;
-    }
-    // Cache is stale or absent — measure in the background
-    let cancelled = false;
-    measureAvgCharWidth(fontFamily, fontWeight, fallback).then((measured) => {
-      if (cancelled) return;
-      const updated = { ...readCache(), [key]: { ratio: measured, measuredAt: Date.now() } };
-      writeCache(updated);
-      setRatio(measured);
-    });
-    return () => {
-      cancelled = true;
-    };
-    // Intentionally excluding `ratio` from deps — we only want to re-measure on key/font change
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [key, fontFamily, fontWeight, fallback]);
-  return ratio;
-}

package/src/fonts/useTypographyCalibrations.ts DELETED Viewed

@@ -1,15 +0,0 @@
-import { useNewtoneTheme } from '../theme/NewtoneProvider';
-/**
- * Returns the per-font avgCharWidth calibrations from the current theme config.
- *
- * These are Layer 1 (editor-time) calibrations — measured with canvas at publish
- * time and stored in `themeConfig.typography.calibrations`. Use `useLocalCalibration`
- * to overlay device-local (Layer 2) measurements on top.
- *
- * @returns Record of fontFamily → avgCharWidthRatio, or an empty object if absent.
- */
-export function useTypographyCalibrations(): Record<string, number> {
-  const { config } = useNewtoneTheme();
-  return config.typography.calibrations ?? {};
-}

package/src/theme/FrameContext.tsx DELETED Viewed

@@ -1,31 +0,0 @@
-import { createContext, useContext } from 'react';
-import type { ElevationLevel } from './types';
-import type { ResolvedTokens } from '../tokens/types';
-/**
- * Context value provided by Frame to its descendants.
- * Contains the resolved elevation and pre-computed tokens.
- * Tokens are included to avoid redundant computeTokens calls in child components.
- */
-export interface FrameContextValue {
-  readonly elevation: ElevationLevel;
-  readonly tokens: ResolvedTokens;
-}
-/**
- * FrameContext - Propagates elevation overrides from Frame to descendants.
- *
- * When null, components fall back to default elevation (1).
- * When present, useTokens() reads from this context instead.
- */
-export const FrameContext = createContext<FrameContextValue | null>(null);
-/**
- * useFrameContext - Read the nearest Frame's context, if any.
- *
- * Returns null when no parent Frame exists. This is intentionally not an error —
- * components outside a Frame simply fall back to the NewtoneProvider defaults.
- */
-export function useFrameContext(): FrameContextValue | null {
-  return useContext(FrameContext);
-}

package/src/theme/NewtoneProvider.tsx DELETED Viewed

@@ -1,84 +0,0 @@
-import React, { createContext, useState, useMemo, useContext } from 'react';
-import type { NewtoneThemeConfig, NewtoneThemeContext, ColorMode } from './types';
-import { DEFAULT_THEME_CONFIG } from './defaults';
-import { GoogleFontLoader } from '../fonts/GoogleFontLoader';
-import { SelfHostedFontLoader } from '../fonts/SelfHostedFontLoader';
-import { IconFontLoader } from '../fonts/IconFontLoader';
-const ThemeContext = createContext<NewtoneThemeContext | null>(null);
-export interface NewtoneProviderProps {
-  readonly config?: NewtoneThemeConfig;
-  readonly initialMode?: ColorMode;
-  readonly children: React.ReactNode;
-  /** Optional URL for typography telemetry. When set, adaptive Text instances report observations. */
-  readonly reportingEndpoint?: string;
-  /**
-   * Self-hosted @font-face CSS from the theme API.
-   * When provided, injects this CSS instead of loading from Google CDN.
-   * Falls back to Google CDN when absent or null.
-   */
-  readonly fontFaceCss?: string | null;
-}
-/**
- * NewtoneProvider - Provides theme context to all Newtone components
- *
- * Wrap your app with this provider to enable mode switching.
- *
- * @example
- * ```tsx
- * <NewtoneProvider initialMode="light">
- *   <App />
- * </NewtoneProvider>
- * ```
- */
-export function NewtoneProvider({
-  config = DEFAULT_THEME_CONFIG,
-  initialMode = 'light',
-  children,
-  reportingEndpoint,
-  fontFaceCss,
-}: NewtoneProviderProps) {
-  const [mode, setMode] = useState<ColorMode>(initialMode);
-  const value = useMemo(
-    () => ({
-      config,
-      mode,
-      setMode,
-      reportingEndpoint,
-    }),
-    [config, mode, reportingEndpoint]
-  );
-  return (
-    <ThemeContext.Provider value={value}>
-      {fontFaceCss ? (
-        <SelfHostedFontLoader fontFaceCss={fontFaceCss} />
-      ) : (
-        <GoogleFontLoader fonts={config.typography.fonts} />
-      )}
-      <IconFontLoader icons={config.icons} />
-      {children}
-    </ThemeContext.Provider>
-  );
-}
-/**
- * useNewtoneTheme - Hook to access theme context
- *
- * Must be used within a NewtoneProvider.
- *
- * @example
- * ```tsx
- * const { mode, setMode } = useNewtoneTheme();
- * ```
- */
-export function useNewtoneTheme(): NewtoneThemeContext {
-  const context = useContext(ThemeContext);
-  if (!context) {
-    throw new Error('useNewtoneTheme must be used within NewtoneProvider');
-  }
-  return context;
-}

package/src/theme/defaults.ts DELETED Viewed

@@ -1,71 +0,0 @@
-import type { NewtoneThemeConfig } from './types';
-import {
-  DEFAULT_NEUTRAL_HUE,
-  DEFAULT_NEUTRAL_SATURATION,
-  DEFAULT_ACCENT_HUE,
-  DEFAULT_ACCENT_SATURATION,
-  DEFAULT_SUCCESS_HUE,
-  DEFAULT_SUCCESS_SATURATION,
-  DEFAULT_WARNING_HUE,
-  DEFAULT_WARNING_SATURATION,
-  DEFAULT_ERROR_HUE,
-  DEFAULT_ERROR_SATURATION,
-} from 'newtone';
-import { DEFAULT_FONT_SLOTS, DEFAULT_FONT_SIZES, DEFAULT_LINE_HEIGHTS, DEFAULT_ROLE_SCALES } from '@newtonedev/fonts';
-// Re-export typography defaults from @newtonedev/fonts (canonical source)
-export { DEFAULT_FONT_SIZES, DEFAULT_LINE_HEIGHTS, DEFAULT_ROLE_SCALES } from '@newtonedev/fonts';
-/**
- * Default theme configuration matching playground defaults.
- * Palettes: [0] Neutral, [1] Accent, [2] Success, [3] Warning, [4] Error
- */
-export const DEFAULT_THEME_CONFIG: NewtoneThemeConfig = {
-  colorSystem: {
-    dynamicRange: {
-      lightest: 1,
-      darkest: 1,
-    },
-    palettes: [
-      { hue: DEFAULT_NEUTRAL_HUE, saturation: DEFAULT_NEUTRAL_SATURATION },
-      { hue: DEFAULT_ACCENT_HUE, saturation: DEFAULT_ACCENT_SATURATION },
-      { hue: DEFAULT_SUCCESS_HUE, saturation: DEFAULT_SUCCESS_SATURATION },
-      { hue: DEFAULT_WARNING_HUE, saturation: DEFAULT_WARNING_SATURATION },
-      { hue: DEFAULT_ERROR_HUE, saturation: DEFAULT_ERROR_SATURATION },
-    ],
-  },
-  spacing: {
-    '00': 0,   // base * 0
-    '02': 2,   // base * 0.25
-    '04': 4,   // base * 0.5
-    '06': 6,   // base * 0.75
-    '08': 8,   // base * 1 (Medium preset, 8px base)
-    '10': 10,  // base * 1.25
-    '12': 12,  // base * 1.5
-    '16': 16,  // base * 2
-    '20': 20,  // base * 2.5
-    '24': 24,  // base * 3
-    '32': 32,  // base * 4
-    '40': 40,  // base * 5
-    '48': 48,  // base * 6
-  },
-  radius: {
-    none: 0,
-    sm: 4,
-    md: 6,
-    lg: 8,
-    xl: 12,
-    pill: 999,
-  },
-  typography: {
-    fonts: DEFAULT_FONT_SLOTS,
-    fontSizes: DEFAULT_FONT_SIZES,
-    lineHeights: DEFAULT_LINE_HEIGHTS,
-    roles: DEFAULT_ROLE_SCALES,
-  },
-  icons: {
-    variant: 'rounded',  // Material Design 3 aesthetic
-    weight: 400,         // Normal weight
-    autoGrade: true,     // Enable mode-aware grade
-  },
-};

package/src/theme/types.ts DELETED Viewed

@@ -1,191 +0,0 @@
-import type { DynamicRange, PaletteConfig } from 'newtone';
-// Re-export font/typography types from @newtonedev/fonts (canonical source)
-export type {
-  FontConfig,
-  FontWeights,
-  FontSlot,
-  FontSizeScale,
-  LineHeightScale,
-  RoleSizeStep,
-  RoleScale,
-  RoleScales,
-  BreakpointKey,
-  Breakpoints,
-  BreakpointRoleScales,
-  FontRuntimeMetrics,
-} from '@newtonedev/fonts';
-import type { FontSlot, FontSizeScale, LineHeightScale, RoleScales, BreakpointRoleScales, FontRuntimeMetrics, TextRole } from '@newtonedev/fonts';
-/**
- * Color mode: light or dark
- */
-export type ColorMode = 'light' | 'dark';
-/**
- * Elevation levels for surfaces (internal)
- * 0 = sunken, 1 = default, 2 = elevated
- */
-export type ElevationLevel = 0 | 1 | 2;
-/**
- * User-facing elevation for Frame component
- * -2 = deeply sunken (inset shadow), -1 = sunken, 0 = default,
- * 1 = elevated, 2 = prominently elevated (drop shadow)
- */
-export type FrameElevation = -2 | -1 | 0 | 1 | 2;
-/**
- * Complete color system configuration
- */
-export interface ColorSystemConfig {
-  readonly dynamicRange: DynamicRange;
-  readonly palettes: ReadonlyArray<PaletteConfig>;
-}
-/**
- * Overrides for hardcoded token computation constants.
- * All values are optional — omitted fields fall back to engine defaults.
- *
- * All values are NV (normalized value / luminosity) offsets on a unified scale.
- * 0.10 means the same 10% luminosity shift whether applied to borders, text,
- * or interactive components. Direction auto-inverts per effective mode
- * (darker in light mode, lighter in dark mode) unless noted otherwise.
- */
-export interface TokenOverrides {
-  // --- Offset fields (all magnitudes, direction auto-inverts per effective mode) ---
-  // Light mode
-  readonly interactiveComponentOffset?: number;      // default: 0.04 (auto-inverts)
-  readonly hoverShift?: number;                      // default: 0.06 (auto-inverts)
-  readonly activeShift?: number;                     // default: 0.08 (auto-inverts)
-  readonly borderOffset?: number;                    // default: 0.08 (auto-inverts)
-  // Dark mode
-  readonly interactiveComponentOffsetDark?: number;  // default: 0.04 (auto-inverts)
-  readonly hoverShiftDark?: number;                  // default: 0.06 (auto-inverts)
-  readonly activeShiftDark?: number;                 // default: 0.08 (auto-inverts)
-  readonly borderOffsetDark?: number;                // default: 0.08 (auto-inverts)
-  readonly borderFocusedOffset?: number;             // default: 0.16 (auto-inverts)
-  readonly borderFocusedOffsetDark?: number;          // default: 0.16 (auto-inverts)
-  readonly borderFilledOffset?: number;              // default: 0.24 (auto-inverts)
-  readonly borderFilledOffsetDark?: number;           // default: 0.24 (auto-inverts)
-  // --- Normalized tokens (light mode: 0 = lightest, 1 = darkest) ---
-  // When present, computeTokens uses absolute positions instead of baseNv + offset.
-  // All themes share the same lightness positions; palette (hue/sat) varies per theme.
-  // Background: absolute positions — ground is Background/01 (elevated)
-  readonly backgroundElevated?: number;              // default: 0    (ground — lightest)
-  readonly backgroundDefault?: number;               // default: 0.03
-  readonly backgroundSunken?: number;                // default: 0.06
-  // Text: absolute positions at bg01 — elevation-compensated by computeTokens on deeper surfaces
-  readonly textPrimaryNormalized?: number;            // default: 0.9  (max contrast)
-  readonly textSecondaryNormalized?: number;          // default: 0.7
-  readonly textTertiaryNormalized?: number;           // default: 0.5
-  readonly textDisabledNormalized?: number;           // default: 0.3
-  // --- Normalized tokens (dark mode: 0 = darkest, 1 = lightest) ---
-  // Same semantics as light mode but scale direction is inverted.
-  // Background: ground is Background/01 (elevated = lightest dark surface)
-  readonly backgroundElevatedDark?: number;           // default: 0.24 (ground — lightest dark surface)
-  readonly backgroundDefaultDark?: number;            // default: 0.20
-  readonly backgroundSunkenDark?: number;             // default: 0.16
-  // Text: absolute positions at bg01 — elevation-compensated by computeTokens on deeper surfaces
-  readonly textPrimaryNormalizedDark?: number;         // default: 1.0  (max contrast — lightest)
-  readonly textSecondaryNormalizedDark?: number;       // default: 0.8
-  readonly textTertiaryNormalizedDark?: number;        // default: 0.6
-  readonly textDisabledNormalizedDark?: number;        // default: 0.4
-}
-/**
- * Newtone theme configuration
- */
-export interface NewtoneThemeConfig {
-  readonly colorSystem: ColorSystemConfig;
-  readonly spacing: {
-    readonly '00': number;  // base * 0
-    readonly '02': number;  // base * 0.25
-    readonly '04': number;  // base * 0.5
-    readonly '06': number;  // base * 0.75
-    readonly '08': number;  // base * 1
-    readonly '10': number;  // base * 1.25
-    readonly '12': number;  // base * 1.5
-    readonly '16': number;  // base * 2
-    readonly '20': number;  // base * 2.5
-    readonly '24': number;  // base * 3
-    readonly '32': number;  // base * 4
-    readonly '40': number;  // base * 5
-    readonly '48': number;  // base * 6
-  };
-  readonly radius: {
-    readonly none: number;    // 0
-    readonly sm: number;      // 4 * multiplier
-    readonly md: number;      // 6 * multiplier
-    readonly lg: number;      // 8 * multiplier
-    readonly xl: number;      // 12 * multiplier
-    readonly pill: 999;       // Fixed large value
-  };
-  readonly typography: {
-    readonly fonts: {
-      readonly main: FontSlot;      // Default/body font (fallback for all scopes)
-      readonly display: FontSlot;   // Headlines, titles, large display text
-      readonly mono: FontSlot;      // Code snippets, technical content
-      readonly currency: FontSlot;  // Monetary amounts, financial data
-    };
-    /** Primitive font size scale — numbered tokens ('01'-'16'), values in px. */
-    readonly fontSizes: FontSizeScale;
-    /** Primitive line height scale — numbered tokens ('01'-'16'), values in px. */
-    readonly lineHeights: LineHeightScale;
-    /** Role mapping — pairs fontSizes and lineHeights for each role x size combination. */
-    readonly roles: RoleScales;
-    /**
-     * Per-font avgCharWidth ratios, keyed by font family name.
-     * Measured with canvas at editor publish time (Layer 1 calibration).
-     * Used by resolveResponsiveSize to improve line break estimation accuracy.
-     * Falls back to 0.55 when absent.
-     */
-    readonly calibrations?: Record<string, number>;
-    /**
-     * Pre-computed role scales for each viewport breakpoint (sm/md/lg).
-     * Enables CSS-only consumers to generate @media rules from the theme JSON
-     * without importing newtone-fonts. Runtime components use useBreakpoint
-     * instead and compute scaling on the fly.
-     */
-    readonly breakpointRoles?: BreakpointRoleScales;
-    /**
-     * Per-font OpenType-derived metrics, keyed by font family name.
-     * Extracted from font binaries at upload time, looked up at publish time.
-     * Used by Text for line height correction (adjustLineHeight),
-     * vertical centering (verticalCenterOffset), and font feature validation.
-     * Falls back to Inter-equivalent defaults when absent.
-     */
-    readonly fontMetrics?: Readonly<Record<string, FontRuntimeMetrics>>;
-    /**
-     * Per-role font weight (CSS font-weight 100–900).
-     * Primary weight path — the Text component uses these values directly.
-     * When populated via toThemeConfig, defaults are merged with user overrides.
-     * Per-instance weight prop still takes priority.
-     */
-    readonly roleWeights?: Partial<Record<TextRole, number>>;
-  };
-  readonly icons: {
-    readonly variant: 'outlined' | 'rounded' | 'sharp';
-    readonly weight: 100 | 200 | 300 | 400 | 500 | 600 | 700;
-    readonly autoGrade: boolean;  // true = mode-aware grade (light=-25, dark=200)
-  };
-  readonly tokenOverrides?: TokenOverrides;
-}
-/**
- * Current theme context state
- */
-export interface NewtoneThemeContext {
-  readonly config: NewtoneThemeConfig;
-  readonly mode: ColorMode;
-  readonly setMode: (mode: ColorMode) => void;
-  /**
-   * Optional URL for the typography telemetry reporting endpoint.
-   * When set, the Text component (in responsive mode) will batch and POST
-   * ObserverPayload observations to this URL for cross-site aggregation.
-   * When absent, no telemetry is sent (opt-in).
-   */
-  readonly reportingEndpoint?: string;
-}

package/src/theme/useBreakpoint.ts DELETED Viewed

@@ -1,14 +0,0 @@
-import { useWindowDimensions } from 'react-native';
-import { getBreakpointForWidth } from '@newtonedev/fonts';
-import type { BreakpointKey } from '@newtonedev/fonts';
-/**
- * Returns the current viewport breakpoint key ('sm' | 'md' | 'lg').
- *
- * Uses `useWindowDimensions` from react-native (cross-platform — works
- * on web via react-native-web) and re-evaluates on window resize.
- */
-export function useBreakpoint(): BreakpointKey {
-  const { width } = useWindowDimensions();
-  return getBreakpointForWidth(width);
-}