@multiplatform.one/theme 7.65.1 → 7.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/theme",
-  "version": "7.65.1",
+  "version": "7.66.0",
   "description": "Tamagui theme system for multiplatform.one",
   "keywords": [
     "multiplatform",
@@ -72,8 +72,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiplatform.one/platform": "^7.65.1",
-    "@multiplatform.one/store": "^7.65.1",
+    "@multiplatform.one/platform": "^7.66.0",
+    "@multiplatform.one/store": "^7.66.0",
     "@tamagui/animations-react-native": "2.7.6",
     "@tamagui/colors": "2.7.6",
     "@tamagui/config": "2.7.6",
@@ -89,8 +89,8 @@
   },
   "devDependencies": {
     "@expo/prebuild-config": "55.0.18",
-    "@multiplatform.one/config": "7.65.1",
-    "@multiplatform.one/test-utils": "7.65.1",
+    "@multiplatform.one/config": "7.66.0",
+    "@multiplatform.one/test-utils": "7.66.0",
     "@tamagui/animations-css": "2.7.6",
     "@tamagui/animations-reanimated": "2.7.6",
     "@tamagui/font-inter": "2.7.6",

package/src/menuRow.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { menuRowFrame } from "./menuRow";
+import { menuRowChecked, menuRowFrame } from "./menuRow";
 
 describe("menuRowFrame (LC-16 shared menu-row geometry)", () => {
   it("spans the overlay edge-to-edge with its own horizontal padding (SP-EDGE)", () => {
@@ -30,3 +30,9 @@ describe("menuRowFrame (LC-16 shared menu-row geometry)", () => {
     expect(menuRowFrame).not.toHaveProperty("paddingVertical");
   });
 });
+
+describe("menuRowChecked (LC-262 / LC-172 checked row)", () => {
+  it("draws no fill: the check mark carries the selection (FZ-8355)", () => {
+    expect(menuRowChecked).toEqual({ backgroundColor: "transparent" });
+  });
+});

package/src/menuRow.ts

@@ -33,3 +33,13 @@ export const menuRowFrame = {
   userSelect: "none",
   backgroundColor: "transparent",
 } as const;
+
+/**
+ * LC-262 / LC-172: a checked or selected menu or picker row draws no fill in
+ * either scheme; the accent check alone marks it. A per-row `$color2` plate
+ * read as nothing in light and near-black in dark (FZ-8355). Hover, press and
+ * keyboard focus stay transient feedback, owned by each consumer.
+ */
+export const menuRowChecked = {
+  backgroundColor: "transparent",
+} as const;

package/src/theme/defaults/fonts.ts

@@ -7,6 +7,7 @@ import { createFont, type GenericFont } from "@tamagui/web";
 import { flooredLineHeight, fontCategoryMetrics } from "../fontCategoryMetrics";
 import { fontCategoryStacks } from "../fontCategoryStacks";
 import type { FontCategory } from "../knobs";
+import { nativeCategoryFamily } from "../nativeFontFamily";
 import { generateScale, type ScaleFonts } from "../scale/generateScale";
 import { defaultScaleInputs } from "../scale/scaleInputs";
 
@@ -137,7 +138,7 @@ export function createCategoryFont(
 ): GenericFont {
   const sizes = scope === "heading" ? tables.headingSizes : tables.bodySizes;
   return createFont({
-    family,
+    family: nativeCategoryFamily(category, family),
     size: { ...sizes },
     lineHeight: categoryLineHeights(category, tables, scope),
     weight: scope === "heading" ? headingWeights : bodyWeights,
@@ -310,6 +311,44 @@ function deriveHeading(source: HeadingSource, tables: ScaleFonts): GenericFont {
   return font;
 }
 
+function familyOf(font: GenericFont): string | undefined {
+  const family = font.family as string | { val?: string } | undefined;
+  return typeof family === "string" ? family : family?.val;
+}
+
+type FaceName = string | { val?: string } | undefined;
+type FaceMap = Record<string, Record<string, FaceName> | undefined>;
+
+/**
+ * `createFont` fills every weight a face map lacks with `{ normal: family }`,
+ * and tamagui's native split swaps the family for that entry and drops the
+ * weight. Entries that only repeat the renamed family go, so the weight
+ * reaches the platform face; a named face (a bundled bold) stays.
+ */
+function withoutFamilyFill(face: GenericFont["face"], family: string): GenericFont["face"] {
+  if (!face) return face;
+  const kept: FaceMap = {};
+  for (const [weight, styles] of Object.entries(face as FaceMap)) {
+    const named = Object.entries(styles ?? {}).filter(([, name]) => {
+      const value = typeof name === "string" ? name : name?.val;
+      return value !== undefined && value !== family;
+    });
+    if (named.length) kept[weight] = Object.fromEntries(named);
+  }
+  return Object.keys(kept).length ? (kept as GenericFont["face"]) : undefined;
+}
+
+/** A consumer category font keeps its object unless native must rename its family. */
+function withNativeFamily(category: FontCategory, font: GenericFont | undefined) {
+  const family = font && familyOf(font);
+  if (!font || family === undefined) return font;
+  const resolved = nativeCategoryFamily(category, family);
+  if (resolved === family) return font;
+  const { face, ...rest } = font;
+  const kept = withoutFamilyFill(face, family);
+  return { ...rest, family: resolved, ...(kept ? { face: kept } : {}) } as GenericFont;
+}
+
 export function withDerivedHeadingCategories(
   fonts: Record<string, GenericFont>,
   tables: ScaleFonts = defaultTypeTables,
@@ -317,18 +356,19 @@ export function withDerivedHeadingCategories(
   const result = { ...fonts };
   for (const [category, key] of Object.entries(headingCategoryFontKeys)) {
     const source = fonts[category];
-    if (
-      fonts[key] !== defaultFonts[key] ||
-      !source ||
-      source === defaultFonts[category as keyof typeof defaultFonts]
-    )
+    const resolvedSource = withNativeFamily(category as FontCategory, source);
+    if (resolvedSource) result[category] = resolvedSource;
+    if (fonts[key] !== defaultFonts[key]) {
+      const heading = withNativeFamily(category as FontCategory, fonts[key]);
+      if (heading) result[key] = heading;
       continue;
-    const family = source.family as string | { val: string };
+    }
+    if (!resolvedSource || source === defaultFonts[category as keyof typeof defaultFonts]) continue;
     result[key] = deriveHeading(
       {
         category: category as FontCategory,
-        family: typeof family === "string" ? family : family.val,
-        face: source.face,
+        family: familyOf(resolvedSource) ?? "",
+        face: resolvedSource.face,
       },
       tables,
     );

package/src/theme/monoFamily.native.spec.ts

@@ -0,0 +1,187 @@
+/**
+ * LC-137 NATIVE-FONT-FAMILY, the mono category on device (FZ-8143). The SHC
+ * console on an iPhone 16 sim drew every bold `$mono` hostname in the
+ * proportional system face: `$mono` reached React Native as a CSS stack, and
+ * iOS matches no family against a stack.
+ *
+ * Each registered mono font is resolved the way the device resolves it:
+ * tamagui's native `face` swap first, then iOS RCTFont (a known family's
+ * nearest-weight face, else the system face) or Android (`monospace` takes
+ * the weight, an unknown family falls to the default sans).
+ */
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("tamagui", () => ({ createTamagui: (config: unknown) => config }));
+vi.mock("./animations/index", () => ({ animations: {} }));
+
+const os = vi.hoisted(() => ({ current: "ios" as "ios" | "android" }));
+vi.mock("react-native", () => ({
+  Platform: {
+    get OS() {
+      return os.current;
+    },
+  },
+}));
+
+// A glob, not an import: the spec has to load and fail its assertions on
+// code that has no native twin yet.
+const nativeTwin = import.meta.glob<Record<string, unknown>>("./nativeFontFamily.native.ts");
+
+type Face = { family: string; weight: number; mono: boolean };
+type Font = {
+  family?: string | { val?: string };
+  weight?: Record<string, string>;
+  face?: Record<string, { normal?: string | { val?: string } }>;
+};
+
+/** Families iOS ships, by face: what `UIFont.fontNamesForFamilyName` returns. */
+const iosFamilies: Record<string, { name: string; weight: number }[]> = {
+  Menlo: [
+    { name: "Menlo-Regular", weight: 400 },
+    { name: "Menlo-Bold", weight: 700 },
+  ],
+  "Courier New": [
+    { name: "CourierNewPSMT", weight: 400 },
+    { name: "CourierNewPS-BoldMT", weight: 700 },
+  ],
+};
+const iosMonoFaces = new Set([
+  "Menlo-Regular",
+  "Menlo-Bold",
+  "CourierNewPSMT",
+  "CourierNewPS-BoldMT",
+]);
+
+/** The type ramp's weights: the v5 tables plus every weight a use site writes. */
+const rampWeights = ["400", "500", "600", "700", "800"];
+
+function plainFamily(font: Font): string | undefined {
+  return typeof font.family === "string" ? font.family : font.family?.val;
+}
+
+function resolveOnDevice(font: Font, fontWeight: string): Face {
+  let family = plainFamily(font) ?? "System";
+  let weight: string | undefined = fontWeight;
+  const swap = font.face?.[fontWeight]?.normal;
+  const swapped = typeof swap === "string" ? swap : swap?.val;
+  if (swapped) {
+    family = swapped;
+    weight = undefined;
+  }
+  const want = Number(weight ?? 400);
+  if (os.current === "android") {
+    if (family === "monospace") return { family, weight: want, mono: true };
+    return { family: "sans-serif", weight: want, mono: false };
+  }
+  const faces = iosFamilies[family];
+  if (!faces) return { family: "SF Pro (system)", weight: want, mono: false };
+  const face = faces.reduce((best, next) =>
+    Math.abs(next.weight - want) < Math.abs(best.weight - want) ? next : best,
+  );
+  return { family: face.name, weight: face.weight, mono: iosMonoFaces.has(face.name) };
+}
+
+async function nativeFonts(
+  target: "ios" | "android",
+  consumerMono?: (createDefaultFont: typeof import("../font").createDefaultFont) => unknown,
+) {
+  os.current = target;
+  vi.resetModules();
+  vi.doMock("./nativeFontFamily", () => nativeTwin["./nativeFontFamily.native.ts"]!());
+  const { createDefaultFont } = await import("../font");
+  const { createDefaultThemeConfig } = await import("./createDefaultThemeConfig");
+  const { densePreset } = await import("./presets");
+  const config = createDefaultThemeConfig({
+    presets: { dense: densePreset },
+    ...(consumerMono ? { fonts: { mono: consumerMono(createDefaultFont) as never } } : {}),
+  });
+  const base = config.tamagui.fonts as unknown as Record<string, Font>;
+  const dense = config.scales?.dense?.tamagui().fonts as unknown as Record<string, Font>;
+  return { base, dense };
+}
+
+function expectMonoAtEveryWeight(fonts: Record<string, Font>, label: string) {
+  for (const key of ["mono", "headingMono"]) {
+    const font = fonts[key];
+    expect(font, `${label} ${key}`).toBeDefined();
+    for (const weight of rampWeights) {
+      const face = resolveOnDevice(font!, weight);
+      expect(face.mono, `${label} $${key} @${weight} -> ${face.family}`).toBe(true);
+    }
+    const bold = resolveOnDevice(font!, "700");
+    expect(bold.weight, `${label} $${key} @700 is bold`).toBeGreaterThanOrEqual(700);
+    const regular = resolveOnDevice(font!, "400");
+    expect(regular.weight, `${label} $${key} @400 is regular`).toBe(400);
+  }
+}
+
+afterEach(() => {
+  vi.doUnmock("./nativeFontFamily");
+  vi.resetModules();
+});
+
+describe("$mono resolves to a monospaced face at every weight on native (LC-137, FZ-8143)", () => {
+  it.each(["ios", "android"] as const)("MPO's own $mono on %s", async (target) => {
+    const { base, dense } = await nativeFonts(target);
+    expectMonoAtEveryWeight(base, `${target} default`);
+    expectMonoAtEveryWeight(dense, `${target} dense scale`);
+  });
+
+  it.each(["ios", "android"] as const)(
+    "a consumer $mono registered as a CSS stack on %s (the SHC console's)",
+    async (target) => {
+      // `face: {}` through createFont fills every weight with the stack, and
+      // the native face swap then drops the weight: proportional regular.
+      const { base, dense } = await nativeFonts(target, (createDefaultFont) =>
+        createDefaultFont({
+          family: "'IBM Plex Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+          weight: { 1: "400", 4: "400", true: "400", 5: "500", 7: "600" },
+          face: {},
+        }),
+      );
+      expectMonoAtEveryWeight(base, `${target} stack`);
+      expectMonoAtEveryWeight(dense, `${target} stack dense`);
+    },
+  );
+
+  it.each(["ios", "android"] as const)(
+    "a consumer $mono naming another platform's system mono on %s (Kitchen Sink's Menlo)",
+    async (target) => {
+      const { base } = await nativeFonts(target, (createDefaultFont) =>
+        createDefaultFont({ family: "Menlo" }),
+      );
+      expectMonoAtEveryWeight(base, `${target} Menlo`);
+    },
+  );
+
+  it("keeps a named face while dropping the stack fill", async () => {
+    const { base } = await nativeFonts("ios", (createDefaultFont) =>
+      createDefaultFont({
+        family: "'Plex', ui-monospace, monospace",
+        face: { 800: { normal: "IBMPlexMono-ExtraBold" } },
+      }),
+    );
+    const face = base.mono!.face!;
+    expect(Object.keys(face).filter((weight) => Number(weight) < 800)).toEqual([]);
+    expect(face["800"]?.normal).toBe("IBMPlexMono-ExtraBold");
+    expect(resolveOnDevice(base.mono!, "700")).toMatchObject({ family: "Menlo-Bold", mono: true });
+  });
+
+  it("keeps a single family the app bundles", async () => {
+    const { base } = await nativeFonts("ios", (createDefaultFont) =>
+      createDefaultFont({ family: "JetBrains Mono" }),
+    );
+    expect(plainFamily(base.mono!)).toBe("JetBrains Mono");
+    expect(plainFamily(base.headingMono!)).toBe("JetBrains Mono");
+  });
+
+  it("leaves the web stack and every other category untouched", async () => {
+    vi.resetModules();
+    const { defaultFonts } = await import("./defaults/fonts");
+    const { fontCategoryStacks } = await import("./fontCategoryStacks");
+    expect(defaultFonts.mono.family).toBe(fontCategoryStacks.mono);
+    const { base } = await nativeFonts("ios");
+    expect(plainFamily(base.pixel!)).toBe(fontCategoryStacks.pixel);
+    expect(plainFamily(base.serif!)).toBe(fontCategoryStacks.serif);
+  });
+});

package/src/theme/nativeFontFamily.native.ts

@@ -0,0 +1,14 @@
+import { Platform } from "react-native";
+import type { FontCategory } from "./knobs";
+import { resolveNativeMonoFamily } from "./nativeMonoFamily";
+
+/**
+ * One registered family per category on iOS and Android, never a CSS stack
+ * (LC-137). Other native hosts keep the stack: GNOME's Pango reads a
+ * comma-separated family list.
+ */
+export function nativeCategoryFamily(category: FontCategory, family: string): string {
+  if (category !== "mono") return family;
+  if (Platform.OS !== "ios" && Platform.OS !== "android") return family;
+  return resolveNativeMonoFamily(family, Platform.OS);
+}

package/src/theme/nativeFontFamily.ts

@@ -0,0 +1,6 @@
+import type { FontCategory } from "./knobs";
+
+/** Web keeps the CSS stack; the native twin resolves it to one family (LC-137). */
+export function nativeCategoryFamily(_category: FontCategory, family: string): string {
+  return family;
+}

package/src/theme/nativeMonoFamily.ts

@@ -0,0 +1,46 @@
+/**
+ * LC-137 NATIVE-FONT-FAMILY for the mono category (FZ-8143).
+ *
+ * React Native takes one family name. A CSS stack, or a system mono that
+ * only another platform ships, matches nothing: iOS draws the proportional
+ * system face and Android its default sans, at whatever weight survives.
+ * Each native platform has one monospaced family with every weight the type
+ * ramp asks for reachable through `fontWeight`: Menlo on iOS (Regular and
+ * Bold, matched by nearest weight) and `monospace` on Android (weight
+ * applied by the platform). A single family the app bundles is kept.
+ */
+export type NativeOS = "ios" | "android";
+
+export const platformMonoFamily: Record<NativeOS, string> = {
+  ios: "Menlo",
+  android: "monospace",
+};
+
+const shippedMono: Record<NativeOS, ReadonlySet<string>> = {
+  ios: new Set(["Menlo", "Courier", "Courier New"]),
+  android: new Set(["monospace"]),
+};
+
+const systemMono = new Set([
+  "ui-monospace",
+  "monospace",
+  "SFMono-Regular",
+  "SF Mono",
+  "Menlo",
+  "Monaco",
+  "Consolas",
+  "Courier",
+  "Courier New",
+  "Liberation Mono",
+  "DejaVu Sans Mono",
+  "Cascadia Code",
+  "Cascadia Mono",
+]);
+
+export function resolveNativeMonoFamily(family: string, os: NativeOS): string {
+  if (family.includes(",")) return platformMonoFamily[os];
+  const name = family.trim().replace(/^(['"])(.*)\1$/, "$2");
+  if (shippedMono[os].has(name)) return name;
+  if (systemMono.has(name)) return platformMonoFamily[os];
+  return name;
+}

package/types/menuRow.d.ts

@@ -33,4 +33,13 @@ export declare const menuRowFrame: {
     readonly userSelect: "none";
     readonly backgroundColor: "transparent";
 };
+/**
+ * LC-262 / LC-172: a checked or selected menu or picker row draws no fill in
+ * either scheme; the accent check alone marks it. A per-row `$color2` plate
+ * read as nothing in light and near-black in dark (FZ-8355). Hover, press and
+ * keyboard focus stay transient feedback, owned by each consumer.
+ */
+export declare const menuRowChecked: {
+    readonly backgroundColor: "transparent";
+};
 //# sourceMappingURL=menuRow.d.ts.map

package/types/menuRow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"menuRow.d.ts","sourceRoot":"","sources":["../src/menuRow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAQf,CAAC"}
+{"version":3,"file":"menuRow.d.ts","sourceRoot":"","sources":["../src/menuRow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAQf,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;CAEjB,CAAC"}

package/types/theme/defaults/fonts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../../../src/theme/defaults/fonts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../../../src/theme/defaults/fonts.ts"],"names":[],"mappings":"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"}

package/types/theme/nativeFontFamily.d.ts

@@ -0,0 +1,4 @@
+import type { FontCategory } from "./knobs";
+/** Web keeps the CSS stack; the native twin resolves it to one family (LC-137). */
+export declare function nativeCategoryFamily(_category: FontCategory, family: string): string;
+//# sourceMappingURL=nativeFontFamily.d.ts.map

package/types/theme/nativeFontFamily.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeFontFamily.d.ts","sourceRoot":"","sources":["../../src/theme/nativeFontFamily.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,mFAAmF;AACnF,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpF"}

package/types/theme/nativeFontFamily.native.d.ts

@@ -0,0 +1,8 @@
+import type { FontCategory } from "./knobs";
+/**
+ * One registered family per category on iOS and Android, never a CSS stack
+ * (LC-137). Other native hosts keep the stack: GNOME's Pango reads a
+ * comma-separated family list.
+ */
+export declare function nativeCategoryFamily(category: FontCategory, family: string): string;
+//# sourceMappingURL=nativeFontFamily.native.d.ts.map

package/types/theme/nativeFontFamily.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeFontFamily.native.d.ts","sourceRoot":"","sources":["../../src/theme/nativeFontFamily.native.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAInF"}

package/types/theme/nativeMonoFamily.d.ts

@@ -0,0 +1,15 @@
+/**
+ * LC-137 NATIVE-FONT-FAMILY for the mono category (FZ-8143).
+ *
+ * React Native takes one family name. A CSS stack, or a system mono that
+ * only another platform ships, matches nothing: iOS draws the proportional
+ * system face and Android its default sans, at whatever weight survives.
+ * Each native platform has one monospaced family with every weight the type
+ * ramp asks for reachable through `fontWeight`: Menlo on iOS (Regular and
+ * Bold, matched by nearest weight) and `monospace` on Android (weight
+ * applied by the platform). A single family the app bundles is kept.
+ */
+export type NativeOS = "ios" | "android";
+export declare const platformMonoFamily: Record<NativeOS, string>;
+export declare function resolveNativeMonoFamily(family: string, os: NativeOS): string;
+//# sourceMappingURL=nativeMonoFamily.d.ts.map

package/types/theme/nativeMonoFamily.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeMonoFamily.d.ts","sourceRoot":"","sources":["../../src/theme/nativeMonoFamily.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AAEzC,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAGvD,CAAC;AAuBF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,GAAG,MAAM,CAM5E"}