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;

}