Offline gym log for Android. No account, no ads, no internet.
Dart androidbodybuildingdartexercisesf-droidfitnessfluttergymgym-apphealthprivacyself-hostedworkoutworkout-appworkout-tracker
import 'dart:convert';
class PlanSet {
const PlanSet({this.reps, this.repsMax, this.weightKg, this.kind = 0, this.sec, this.km});
final int? reps;
final int? repsMax;
final double? weightKg;
final int kind;
final int? sec;
final double? km;
}
class PlanItem {
const PlanItem(
this.name,
this.sets, {
this.id,
this.reps,
this.repsMax,
this.weightKg,
this.restSec,
this.superset = false,
this.plan = const [],
this.muscle,
this.equipment,
this.level,
this.steps = const [],
this.mode = '',
this.secondary = const [],
this.ladder = const [],
this.loggingNote = '',
this.sec,
this.km,
this.kind = 0,
});
final String name;
final int? sets;
final String? id;
final int? reps;
final int? repsMax;
final double? weightKg;
final int? restSec;
final bool superset;
final List<PlanSet> plan;
final String? muscle;
final List<String> secondary;
final String? equipment;
final String? level;
final List<String> steps;
final String mode;
final List<String> ladder;
final String loggingNote;
final int? sec;
final double? km;
final int kind;
}
class PlanRoutine {
const PlanRoutine(this.name, this.items, {this.group = '', this.days = const []});
final String name;
final List<PlanItem> items;
final String group;
final List<int> days;
}
const _nameKeys = ['name', 'routine', 'title', 'nombre', 'rutina', 'workout', 'day', 'dia'];
const _listKeys = ['exercises', 'items', 'ejercicios', 'movements', 'exercicios', 'esercizi', 'ubungen'];
const _routineListKeys = ['routines', 'rutinas', 'plan', 'days', 'workouts', 'sessions', 'dias'];
const _groupKeys = ['group', 'grupo', 'folder', 'program', 'programme', 'programa', 'split'];
const _weekKeys = ['weeks', 'semanas', 'mesocycle', 'blocks'];
const _dayKeys = ['days', 'dias', 'weekdays', 'schedule', 'on'];
const _setKeys = ['sets', 'series', 'setcount'];
const _repKeys = ['reps', 'repetitions', 'repeticiones', 'rep', 'repeticoes', 'ripetizioni'];
const _repMaxKeys = ['repsmax', 'maxreps', 'repmax', 'maxrep', 'repsto', 'repsmaximum'];
const _weightKeys = ['weight', 'weightkg', 'load', 'kg', 'peso', 'carga', 'lbs', 'lb'];
const _restKeys = ['rest', 'restseconds', 'restsec', 'descanso', 'pause', 'riposo'];
const _timeKeys = ['time', 'duration', 'seconds', 'sec', 'secs', 'tiempo', 'durationseconds'];
const _distanceKeys = ['distance', 'km', 'distancekm', 'distancia'];
const _itemNameKeys = ['name', 'exercise', 'ejercicio', 'movement', 'exercisename', 'title', 'nombre'];
const _weekdayNames = {
1: ['monday', 'mon', 'lunes', 'lun', 'segunda', 'lunedi', 'montag', 'mo'],
2: ['tuesday', 'tue', 'tues', 'martes', 'mar', 'terca', 'martedi', 'dienstag', 'di'],
3: ['wednesday', 'wed', 'miercoles', 'mie', 'quarta', 'mercoledi', 'mittwoch', 'mi'],
4: ['thursday', 'thu', 'thur', 'thurs', 'jueves', 'jue', 'quinta', 'giovedi', 'donnerstag', 'do'],
5: ['friday', 'fri', 'viernes', 'vie', 'sexta', 'venerdi', 'freitag', 'fr'],
6: ['saturday', 'sat', 'sabado', 'sab', 'sabato', 'samstag', 'sa'],
7: ['sunday', 'sun', 'domingo', 'dom', 'domenica', 'sonntag', 'so'],
};
List<PlanRoutine> parsePlan(String raw) {
final data = _decode(raw);
if (data == null) return _parseCsv(raw);
final lb = data is Map<Object?, Object?> && _isLb(_value(data, ['unit', 'units', 'unidad']));
final out = <PlanRoutine>[];
void addRoutine(Map<Object?, Object?> map, String group) {
final items = _items(_value(map, _listKeys), lb);
if (items.isEmpty) return;
final own = _string(_value(map, _groupKeys));
out.add(PlanRoutine(
_string(_value(map, _nameKeys)),
items,
group: own.isNotEmpty ? own : group,
days: _days(_value(map, _dayKeys)),
));
}
void addRoutines(List<Object?> list, String group) {
if (list.isNotEmpty && list.every((e) => e is String)) {
out.add(PlanRoutine('', _items(list, lb), group: group));
return;
}
for (final r in list) {
if (r is Map<Object?, Object?>) addRoutine(r, group);
}
}
if (data is Map<Object?, Object?>) {
final program = _string(_value(data, _groupKeys));
final weeks = _value(data, _weekKeys);
final nested = _routineList(data);
if (weeks is List) {
var n = 0;
for (final w in weeks) {
n++;
if (w is! Map<Object?, Object?>) continue;
final label = _string(_value(w, _nameKeys + ['week', 'semana']));
final week = label.isNotEmpty ? label : 'Week $n';
final group = program.isEmpty ? week : '$program · $week';
final inner = _routineList(w);
if (inner != null) addRoutines(inner, group);
}
} else if (nested != null) {
final name = _string(_value(data, _nameKeys));
addRoutines(nested, program.isNotEmpty ? program : (_listOfRoutines(nested) ? name : ''));
} else {
addRoutine(data, '');
}
} else if (data is List) {
addRoutines(data, '');
}
return out;
}
bool _listOfRoutines(List<Object?> list) =>
list.isNotEmpty && list.every((e) => e is Map<Object?, Object?> && _value(e, _listKeys) is List);
List<Object?>? _routineList(Map<Object?, Object?> map) {
for (final entry in map.entries) {
final k = _norm(entry.key);
final v = entry.value;
if (!_routineListKeys.contains(k) || v is! List) continue;
if (v.isNotEmpty && v.every((e) => e is num || e is String) && _dayKeys.contains(k)) continue;
return v;
}
return null;
}
Object? _decode(String raw) {
for (final text in _candidates(raw)) {
try {
final data = jsonDecode(text);
if (data is Map || data is List) return data;
} catch (_) {
continue;
}
}
return null;
}
List<String> _candidates(String raw) {
final text = raw.trim();
final out = [text];
final fenced = RegExp(r'```(?:json)?\s*([\s\S]*?)```').firstMatch(text);
if (fenced != null) out.add(fenced.group(1)!.trim());
for (final pair in [('{', '}'), ('[', ']')]) {
final start = text.indexOf(pair.$1);
final end = text.lastIndexOf(pair.$2);
if (start >= 0 && end > start) out.add(text.substring(start, end + 1));
}
return out;
}
String _norm(Object? key) => key.toString().toLowerCase().replaceAll(RegExp(r'[^a-z]'), '');
int? _repsMax(Map<Object?, Object?> map, int? low) {
final explicit = _int(_value(map, _repMaxKeys));
final raw = _value(map, _repKeys);
final fromText = raw is String ? RegExp(r'(\d+)\s*(?:-|–|—|to|a)\s*(\d+)').firstMatch(raw)?.group(2) : null;
final max = explicit ?? (fromText == null ? null : int.parse(fromText));
return max != null && low != null && max > low ? max : null;
}
Object? _value(Map<Object?, Object?> map, List<String> keys) {
for (final key in keys) {
for (final entry in map.entries) {
if (_norm(entry.key) == key) return entry.value;
}
}
return null;
}
String _string(Object? v) => v is String ? v.trim() : (v is num ? '$v' : '');
bool _isLb(Object? v) => v is String && RegExp(r'^\s*(lb|lbs|pounds?)\s*$', caseSensitive: false).hasMatch(v);
int? _int(Object? v) {
if (v is num) return v.round();
if (v is String) {
final m = RegExp(r'\d+').firstMatch(v);
return m == null ? null : int.parse(m.group(0)!);
}
return null;
}
double? _double(Object? v) {
if (v is num) return v.toDouble();
if (v is String) {
final m = RegExp(r'\d+(?:[.,]\d+)?').firstMatch(v);
return m == null ? null : double.tryParse(m.group(0)!.replaceAll(',', '.'));
}
return null;
}
double? _weight(Object? v, bool lb) {
final n = _double(v);
if (n == null) return null;
final inLb = lb || (v is String && RegExp(r'lb', caseSensitive: false).hasMatch(v));
return inLb ? n / 2.20462 : n;
}
int? _seconds(Object? v) {
if (v is num) return v.round();
if (v is! String) return null;
final s = v.trim().toLowerCase();
final clock = RegExp(r'^(\d+):(\d{1,2})(?::(\d{1,2}))?$').firstMatch(s);
if (clock != null) {
final a = int.parse(clock.group(1)!), b = int.parse(clock.group(2)!);
final c = clock.group(3);
return c == null ? a * 60 + b : a * 3600 + b * 60 + int.parse(c);
}
final n = _double(s);
if (n == null) return null;
if (s.contains('h')) return (n * 3600).round();
if (s.contains('min') || RegExp(r'\d\s*m\b').hasMatch(s)) return (n * 60).round();
return n.round();
}
int _kind(Object? v) {
final s = _norm(v);
if (s.startsWith('warm') || s.startsWith('calent') || s == 'w') return 1;
if (s.startsWith('drop')) return 2;
if (s.startsWith('fail') || s.startsWith('fallo') || s == 'amrap') return 3;
if (s.startsWith('restpause') || s == 'rp') return 4;
if (s.startsWith('cluster') || s == 'c') return 5;
return 0;
}
List<int> _days(Object? v) {
final list = v is List ? v : (v is String ? v.split(RegExp(r'[,/;\s]+')) : const []);
final out = <int>{};
for (final d in list) {
if (d is num && d >= 1 && d <= 7) out.add(d.toInt());
if (d is String) {
final k = d
.toLowerCase()
.replaceAll(RegExp(r'[áàâä]'), 'a')
.replaceAll(RegExp(r'[éèêë]'), 'e')
.replaceAll(RegExp(r'[íìîï]'), 'i')
.replaceAll(RegExp(r'[óòôö]'), 'o')
.replaceAll(RegExp(r'[úùûü]'), 'u')
.replaceAll('ç', 'c')
.replaceAll(RegExp(r'[^a-z0-9]'), '');
final n = int.tryParse(k);
if (n != null && n >= 1 && n <= 7) {
out.add(n);
continue;
}
for (final e in _weekdayNames.entries) {
if (e.value.contains(k) || (k.length > 3 && e.value.first.startsWith(k))) out.add(e.key);
}
}
}
return out.toList()..sort();
}
List<PlanSet> _planSets(Object? raw, bool lb) {
if (raw is! List) return const [];
final out = <PlanSet>[];
for (final s in raw) {
if (s is! Map<Object?, Object?>) continue;
out.add(PlanSet(
reps: _int(_value(s, _repKeys)),
repsMax: _repsMax(s, _int(_value(s, _repKeys))),
weightKg: _weight(_value(s, _weightKeys), lb || _value(s, ['lbs', 'lb']) != null),
kind: _kind(_value(s, ['type', 'kind', 'tipo', 'settype'])),
sec: _seconds(_value(s, _timeKeys)),
km: _double(_value(s, _distanceKeys)),
));
}
return out;
}
List<PlanItem> _items(Object? raw, bool lb) {
if (raw is! List) return const [];
final out = <PlanItem>[];
for (final entry in raw) {
if (entry is String) {
if (entry.trim().isNotEmpty) out.add(PlanItem(entry.trim(), null));
continue;
}
if (entry is! Map<Object?, Object?>) continue;
final name = _string(_value(entry, _itemNameKeys));
final id = _string(_value(entry, ['id', 'exerciseid']));
if (name.isEmpty && id.isEmpty) continue;
final itemLb = lb || _isLb(_value(entry, ['unit', 'units'])) || _value(entry, ['lbs', 'lb']) != null;
final custom = _value(entry, ['custom', 'own', 'details']);
final info = custom is Map<Object?, Object?> ? custom : const <Object?, Object?>{};
final steps = _value(info, ['steps', 'howto', 'pasos', 'instructions']);
final superset = _value(entry, ['superset', 'supersetwithnext', 'linked', 'chain']);
out.add(PlanItem(
name.isEmpty ? id : name,
_int(_value(entry, _setKeys)),
id: id.isEmpty ? null : id,
reps: _int(_value(entry, _repKeys)),
repsMax: _repsMax(entry, _int(_value(entry, _repKeys))),
weightKg: _weight(_value(entry, _weightKeys), itemLb),
restSec: _seconds(_value(entry, _restKeys)),
superset: superset == true || (superset is String && superset.toLowerCase() == 'true'),
plan: _planSets(_value(entry, ['plan', 'setplan', 'setsplan', 'detail']) ?? (_value(entry, _setKeys) is List ? _value(entry, _setKeys) : null), itemLb),
muscle: _string(_value(info, ['muscle', 'primary', 'musculo'])),
equipment: _string(_value(info, ['equipment', 'material', 'gear'])),
level: _string(_value(info, ['level', 'difficulty', 'nivel'])),
steps: steps is List ? steps.whereType<String>().toList() : const [],
mode: _string(_value(info, ['track', 'mode', 'type'])),
secondary: switch (_value(info, ['secondary', 'secondarymuscles'])) {
final List list => list.whereType<String>().toList(),
_ => const [],
},
ladder: switch (_value(entry, ['progression', 'ladder', 'progresion', 'progressao', 'progressione'])) {
final List list => [for (final s in list.whereType<String>()) if (s.trim().isNotEmpty) s.trim()],
_ => const [],
},
loggingNote: switch (_value(entry, ['loggingnote'])) {
final String note => note.trim(),
_ => '',
},
sec: _seconds(_value(entry, _timeKeys)),
km: _double(_value(entry, _distanceKeys)),
kind: _kind(_value(entry, ['type', 'kind', 'settype', 'tipo'])),
));
}
return _mergeRepeats(out);
}
List<PlanSet> _expanded(PlanItem item) {
if (item.plan.isNotEmpty) {
final working = item.plan.where((p) => p.kind != 1).length;
return [
for (final p in item.plan)
PlanSet(
reps: p.reps ?? item.reps,
repsMax: p.reps == null ? item.repsMax : p.repsMax,
weightKg: p.weightKg ?? item.weightKg,
kind: p.kind,
sec: p.sec ?? item.sec,
km: p.km ?? item.km,
),
for (var i = working; i < (item.sets ?? working); i++)
PlanSet(
reps: item.reps,
repsMax: item.repsMax,
weightKg: item.weightKg,
kind: item.kind,
sec: item.sec,
km: item.km,
),
];
}
return [
for (var i = 0; i < (item.sets ?? 1); i++)
PlanSet(
reps: item.reps,
repsMax: item.repsMax,
weightKg: item.weightKg,
kind: item.kind,
sec: item.sec,
km: item.km,
),
];
}
List<PlanItem> _mergeRepeats(List<PlanItem> items) {
String key(PlanItem i) => (i.id ?? i.name).trim().toLowerCase();
final seen = <String, int>{};
final out = <PlanItem>[];
for (final item in items) {
final at = seen[key(item)];
if (at == null) {
seen[key(item)] = out.length;
out.add(item);
continue;
}
final first = out[at];
final plan = [..._expanded(first), ..._expanded(item)];
out[at] = PlanItem(
first.name,
plan.where((p) => p.kind != 1).length,
id: first.id,
reps: first.reps ?? item.reps,
repsMax: first.repsMax ?? item.repsMax,
weightKg: first.weightKg ?? item.weightKg,
restSec: first.restSec ?? item.restSec,
superset: first.superset || item.superset,
plan: plan,
muscle: first.muscle,
equipment: first.equipment,
level: first.level,
steps: first.steps,
mode: first.mode,
secondary: first.secondary,
ladder: first.ladder,
loggingNote: first.loggingNote.isEmpty ? item.loggingNote : first.loggingNote,
sec: first.sec ?? item.sec,
km: first.km ?? item.km,
kind: first.kind,
);
}
return out;
}
List<List<String>> _rows(String raw) {
final lines = raw.split(RegExp(r'\r?\n')).map((l) => l.trim()).where((l) => l.isNotEmpty).toList();
if (lines.isEmpty) return const [];
final first = lines.first;
final sep = [';', '\t', ','].reduce((a, b) => first.split(a).length >= first.split(b).length ? a : b);
List<String> split(String line) {
final cells = <String>[];
final cell = StringBuffer();
var quoted = false;
for (var i = 0; i < line.length; i++) {
final c = line[i];
if (c == '"') {
quoted = !quoted;
} else if (c == sep && !quoted) {
cells.add(cell.toString().trim());
cell.clear();
} else {
cell.write(c);
}
}
cells.add(cell.toString().trim());
return cells;
}
return lines.map(split).where((r) => r.length >= 2).toList();
}
List<PlanRoutine> _parseCsv(String raw) {
final rows = _rows(raw);
if (rows.isEmpty) return const [];
final head = rows.first.map(_norm).toList();
int col(List<String> keys) => head.indexWhere(keys.contains);
var exercise = col(['exercise', 'ejercicio', 'exercisename', 'movement', 'name']);
var routine = col(['routine', 'rutina', 'workout', 'day', 'dia', 'session']);
var sets = col(_setKeys);
var reps = col(_repKeys);
var weight = col(_weightKeys);
final group = col(['week', 'semana', 'group', 'grupo', 'program']);
final rest = col(_restKeys);
final time = col(_timeKeys);
final distance = col(_distanceKeys);
final days = col(['weekday', 'weekdays', 'schedule']);
final lb = head.any((h) => h == 'lbs' || h == 'lb' || h == 'weightlbs');
var body = rows.skip(1).toList();
if (exercise < 0) {
final probe = rows.first;
if (probe.length < 3 || _int(probe[1]) != null || _int(probe[2]) == null) return const [];
body = rows;
routine = 0;
exercise = 1;
sets = 2;
reps = 3;
weight = 4;
}
String cell(List<String> r, int i) => i >= 0 && i < r.length ? r[i] : '';
final order = <String>[];
final grouped = <String, List<PlanItem>>{};
final groups = <String, String>{};
final schedule = <String, List<int>>{};
for (final r in body) {
final name = cell(r, exercise);
if (name.isEmpty || _int(name) != null) continue;
final g = cell(r, group);
final key = '$g|${cell(r, routine)}';
if (!grouped.containsKey(key)) {
order.add(key);
grouped[key] = [];
groups[key] = g;
schedule[key] = _days(cell(r, days));
}
grouped[key]!.add(PlanItem(
name,
_int(cell(r, sets)),
reps: _int(cell(r, reps)),
weightKg: _weight(cell(r, weight), lb),
restSec: _seconds(cell(r, rest)),
sec: _seconds(cell(r, time)),
km: _double(cell(r, distance)),
));
}
return [
for (final key in order)
PlanRoutine(key.split('|').last, grouped[key]!, group: groups[key]!, days: schedule[key]!),
];
}
String encodePlan(Map<String, Object?> plan) => const JsonEncoder.withIndent(' ').convert(plan);