Экран настроек: тема, единицы, сброс

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  get(id: string): Row | undefined;
}
interface Journal {
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
}
interface Disk {
  getItem(key: string): Promise<string | null>;
  setItem(key: string, value: string): Promise<void>;
}
declare const disk: Disk;
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

type Prefs = { units: string; restSec: number; theme: string };
const BY_DEFAULT: Prefs = { units: "kg", restSec: 60, theme: "light" };
const SETTINGS = "settings";
const show = (prefs: Prefs) => prefs.units + " | отдых " + prefs.restSec + " | тема " + prefs.theme;

// «настройки — дело устройства»: у каждого свой ящик, то есть свой ключ
async function inBox() {
  await disk.setItem("A:prefs", JSON.stringify({ ...BY_DEFAULT, units: "lb", theme: "dark" }));
  const phone = JSON.parse((await disk.getItem("A:prefs")) ?? "null") ?? BY_DEFAULT;
  const web = JSON.parse((await disk.getItem("B:prefs")) ?? "null") ?? BY_DEFAULT;
  console.log("ящик, телефон:", show(phone));
  console.log("ящик, веб-версия:", show(web));
}

// «настройки — такие же данные»: обычная строка дневника, она уезжает и приезжает
function inJournal() {
  const server = createServer();
  const phone = createClient("A", server);
  const web = createClient("B", server);
  phone.journal.change(SETTINGS, { ...BY_DEFAULT, units: "lb", theme: "dark" });
  phone.sync();
  web.sync();
  const row = web.store.get(SETTINGS);
  console.log("дневник, веб-версия:", row ? show({ units: String(row.units), restSec: Number(row.restSec), theme: String(row.theme) }) : "нет строки");
}

(async () => {
  await inBox();
  inJournal();
})();

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  get(id: string): Row | undefined;
}
interface Journal {
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

// имя строки настроек не рождается на телефоне: оно одно на человека,
// иначе у каждого устройства была бы своя строка настроек
const SETTINGS = "settings";
type Save = (client: Client, patch: Fields) => void;

// один вечер: на телефоне включают фунты, на вебе ставят отдых в 90 секунд
function evening(save: Save) {
  const server = createServer();
  const phone = createClient("A", server);
  const web = createClient("B", server);
  phone.journal.change(SETTINGS, { units: "kg", restSec: 60 });
  phone.sync();
  web.sync();
  save(phone, { units: "lb" });
  save(web, { restSec: 90 });
  web.sync();
  phone.sync();
  web.sync();
  return JSON.stringify(phone.store.get(SETTINGS));
}

// экран, собранный как форма: «Сохранить» отправляет все поля разом
const whole: Save = (client, patch) =>
  client.journal.change(SETTINGS, { ...client.store.get(SETTINGS), ...patch });
// экран настроек: переключатель отправляет только то, что человек тронул
const touched: Save = (client, patch) => client.journal.change(SETTINGS, patch);

console.log("строкой целиком:", evening(whole));
console.log("одним полем:", evening(touched));

interface Disk {
  getItem(key: string): Promise<string | null>;
  setItem(key: string, value: string): Promise<void>;
}
declare const disk: Disk;
const { Text } = ReactNative;

type Device = { theme: "light" | "dark"; keepAwake: boolean };
const DEFAULTS: Device = { theme: "light", keepAwake: true };

// ящик устройства: значение в памяти, подписка — как у хранилища дневника.
// Новый объект только при записи: иначе useSyncExternalStore зациклится
function createDevicePrefs(key: string) {
  let value = DEFAULTS;
  const listeners = new Set<() => void>();
  const tell = () => listeners.forEach((listener) => listener());
  return {
    get: () => value,
    subscribe: (listener: () => void) => {
      listeners.add(listener);
      return () => {
        listeners.delete(listener);
      };
    },
    hydrate: async () => {
      const text = await disk.getItem(key);
      if (text) value = { ...DEFAULTS, ...JSON.parse(text) };
      tell();
    },
    set: (patch: Partial<Device>) => {
      value = { ...value, ...patch };
      tell();
      return disk.setItem(key, JSON.stringify(value));
    },
  };
}

const prefs = createDevicePrefs("A:device");

function Screen() {
  const device = React.useSyncExternalStore(prefs.subscribe, prefs.get);
  console.log("кадр:", device.theme === "dark" ? "тёмная" : "светлая");
  return <Text>{device.theme}</Text>;
}

// так ящик оставил прошлый запуск: человек выбрал тёмную тему
disk.setItem("A:device", JSON.stringify({ theme: "dark", keepAwake: true }));
mount(<Screen />);
prefs.hydrate();

// shared/settings/device-prefs.native.ts — рядом лежит device-prefs.web.ts
import AsyncStorage from "@react-native-async-storage/async-storage";

// та же форма, что у ящика в примерах: строки по ключу, каждый вызов — промис
export const box = {
  getItem: (key: string) => AsyncStorage.getItem(key),
  setItem: (key: string, value: string) => AsyncStorage.setItem(key, value),
};

// shared/settings/keep-awake/keep-awake.tsx
import { useKeepAwake } from "expo-keep-awake";

// хук держит замок, пока компонент смонтирован, и снимает его при размонтировании.
// Компонент нужен потому, что хук нельзя позвать по условию: настройка выключена —
// элемент просто не рисуется
export function KeepAwake() {
  useKeepAwake();
  return null;
}

// app/(main)/workout/[id].tsx — экран тренировки
// {keepAwake ? <KeepAwake /> : null}

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
interface Store {
  visible(): Row[];
  sets(): Row[];
  subscribe(listener: () => void): () => void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
}
interface Server {
  rows: Map<string, Row>;
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;
const { View, Text, Pressable } = ReactNative;

const SETTINGS = "settings";
type Units = "kg" | "lb";
const app = createClient("A", createServer());
app.journal.change(SETTINGS, { units: "kg", restSec: 60 });
app.journal.change(app.journal.newId(), { exercise: "жим", weightKg: 82.5, reps: 5 });

// настройки читаются той же подпиской, что и дневник: это строка того же хранилища
function useSettings() {
  const rows = React.useSyncExternalStore(app.store.subscribe, app.store.visible);
  const row = React.useMemo(() => rows.find((r) => r.id === SETTINGS), [rows]);
  return { units: (row?.units === "lb" ? "lb" : "kg") as Units, restSec: Number(row?.restSec ?? 60) };
}
// вес лежит в килограммах всегда: фунты — это вид, а не данные
const weight = (kg: number, units: Units) => (units === "lb" ? (kg * 2.2046226).toFixed(1) + " lb" : kg + " кг");

function Header() {
  console.log("шапка:", useSettings().units);
  return <Text>Подход</Text>;
}
function Feed() {
  const { units } = useSettings();
  const sets = React.useSyncExternalStore(app.store.subscribe, app.store.sets);
  console.log("лента:", sets.map((set) => weight(Number(set.weightKg), units)).join(", "));
  return <View>{sets.map((set) => <Text key={set.id}>{weight(Number(set.weightKg), units)}</Text>)}</View>;
}
function RestTimer() {
  console.log("таймер отдыха:", useSettings().restSec);
  return <Text>отдых</Text>;
}
function SettingsScreen() {
  const { units } = useSettings();
  return (
    <Pressable testID="units" onPress={() => app.journal.change(SETTINGS, { units: units === "kg" ? "lb" : "kg" })}>
      <Text>Единицы: {units}</Text>
    </Pressable>
  );
}

mount(<View><Header /><Feed /><RestTimer /><SettingsScreen /></View>);
setTimeout(() => fireEvent.press("units"), 50);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  sets(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
phone.journal.change(phone.journal.newId(), { exercise: "жим", weightKg: 82.5, reps: 5 });

// «Стереть копию на этом телефоне» — только при пустой очереди:
// неотправленное существует только здесь
function wipeLocal(client: Client): string {
  const pending = client.queue().length;
  return pending > 0 ? "не стёрли: ждут отправки " + pending : "стёрли";
}

console.log("сразу после зала:", wipeLocal(phone));
phone.sync();
console.log("после синхронизации:", wipeLocal(phone));

// стёрли и открыли приложение заново: журнал пуст, имя устройства новое
const afterWipe = createClient("A2", server);
console.log("после стирания: подходов", afterWipe.store.sets().length);
afterWipe.sync();
console.log("после первой синхронизации: подходов", afterWipe.store.sets().length);

// «Удалить дневник везде» — надгробие на каждую строку
afterWipe.store.sets().forEach((row) => afterWipe.journal.remove(row.id));
afterWipe.sync();
web.sync();
console.log("удалили везде: на телефоне", afterWipe.store.sets().length,
  "| на вебе", web.store.sets().length, "| строк у сервера", server.rows.size);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
interface Server {
  rows: Map<string, Row>;
  net: { offline: boolean; loseResponse: boolean; unauthorized: boolean };
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
phone.journal.change(phone.journal.newId(), { exercise: "жим", weightKg: 82.5, reps: 5 });

// «Выйти» — не выключатель, а вопрос: у выхода есть цена, и её надо назвать
function askSignOut(client: Client): string {
  const pending = client.queue().length;
  return pending > 0 ? "Не отправлено подходов: " + pending + ". Выйти всё равно?" : "Выходим";
}

server.net.offline = true;
try {
  phone.sync();
} catch (error) {
  console.log("в зале:", (error as Error).message);
}
console.log("нажали «Выйти»:", askSignOut(phone));

server.net.offline = false;
phone.sync();
console.log("после синхронизации:", askSignOut(phone), "| строк у сервера", server.rows.size);