malice

export interface PowerLevels {

  ban: number;

  kick: number;

  redact: number;

  events_default: number;

  state_default: number;

  users_default: number;

  users: Map<string, number>;

  events: Map<string, number>;

  creators: Set<string>;

}

function num(raw: Record<string, unknown>, key: string, fallback: number): number {

  const value = raw[key];

  return typeof value === 'number' && Number.isFinite(value) ? value : fallback;

}

function pairs(raw: unknown): Map<string, number> {

  const out = new Map<string, number>();

  if (!Array.isArray(raw)) return out;

  for (const entry of raw) {

    if (Array.isArray(entry) && typeof entry[0] === 'string' && typeof entry[1] === 'number') out.set(entry[0], entry[1]);

  }

  return out;

}

export function parsePowerLevels(raw: unknown): PowerLevels | null {

  if (typeof raw !== 'object' || raw === null) return null;

  const o = raw as Record<string, unknown>;

  return {

    ban: num(o, 'ban', 50),

    kick: num(o, 'kick', 50),

    redact: num(o, 'redact', 50),

    events_default: num(o, 'events_default', 0),

    state_default: num(o, 'state_default', 50),

    users_default: num(o, 'users_default', 0),

    users: pairs(o['users']),

    events: pairs(o['events']),

    creators: new Set(Array.isArray(o['creators']) ? o['creators'].filter((c): c is string => typeof c === 'string') : [])

  };

}

export function levelOf(levels: PowerLevels, userId: string): number {

  if (levels.creators.has(userId)) return Infinity;

  return levels.users.get(userId) ?? levels.users_default;

}

export function isMuted(levels: PowerLevels, userId: string): boolean {

  const send = Math.min(levels.events_default, levels.events.get('m.room.message') ?? Infinity);

  return levelOf(levels, userId) < send;

}

export interface Allowed {

  kick: boolean;

  ban: boolean;

  setLevel: boolean;

  maxLevel: number;

}

/** What `self` may do to `target`, per the spec's rule that you can only act on users below you. */

export function allowed(levels: PowerLevels, self: string, target: string): Allowed {

  const mine = levelOf(levels, self);

  const theirs = levelOf(levels, target);

  const outranks = self !== target && mine > theirs;

  const plEvent = levels.events.get('m.room.power_levels') ?? levels.state_default;

  return {

    kick: outranks && mine >= levels.kick,

    ban: outranks && mine >= levels.ban,

    setLevel: (outranks || self === target) && mine >= plEvent,

    maxLevel: mine

  };

}

/** Your own messages need only the redaction event level, anyone else's need `redact` too. */

export function canRedact(levels: PowerLevels, self: string, sender: string): boolean {

  const mine = levelOf(levels, self);

  const send = levels.events.get('m.room.redaction') ?? levels.events_default;

  return mine >= send && (self === sender || mine >= levels.redact);

}

export function roleName(level: number): string | null {

  if (level === Infinity) return 'Creator';

  if (level >= 100) return 'Admin';

  if (level >= 50) return 'Moderator';

  return null;

}

export interface GroupedMember {

  user_id: string;

  name: string;

  display_name: string | null;

  membership: string | { Custom: string };

}

export interface MemberGroup<T> {

  label: string;

  members: T[];

}

const ROLE_ORDER = ['Creator', 'Admin', 'Moderator', 'Members', 'Invited'];

/** Joined members by role, highest level first, then invites. */

export function groupMembers<T extends GroupedMember>(members: T[], levels: PowerLevels | null): MemberGroup<T>[] {

  const level = (m: T) => (levels ? levelOf(levels, m.user_id) : 0);

  const label = (m: T) => (m.membership === 'Invited' ? 'Invited' : (roleName(level(m)) ?? 'Members'));

  const name = (m: T) => (m.display_name || m.name || m.user_id).toLowerCase();

  const sorted = [...members].sort((a, b) => {

    const levelDiff = level(b) - level(a);

    if (!Number.isNaN(levelDiff) && levelDiff !== 0) return levelDiff;

    return name(a).localeCompare(name(b)) || a.user_id.localeCompare(b.user_id);

  });

  const groups = new Map<string, T[]>();

  for (const m of sorted) {

    if (m.membership !== 'Joined' && m.membership !== 'Invited') continue;

    const key = label(m);

    groups.set(key, [...(groups.get(key) ?? []), m]);

  }

  return ROLE_ORDER.filter((key) => groups.has(key)).map((key) => ({ label: key, members: groups.get(key)! }));

}