malice

import assert from 'node:assert/strict';

import { test } from 'node:test';

import { clonePackDestinations, cloneRequest, editableChoices, findSticker, freePackStateKey, packsForRoom, packSlug, reactionShortcode, shortcodeFor, stickersOf } from '../src/lib/packs.ts';

const image = (shortcode: string, usage: ('Emoticon' | 'Sticker')[]) => ({

  shortcode,

  media_id: `mxc://x/${shortcode}`,

  reaction_key: `mxc://x/${shortcode}`,

  body: null,

  mimetype: null,

  width: null,

  height: null,

  usage

});

const roomPack = (state_key: string, editable: boolean) => ({

  id: `room:!r:x:${state_key}`,

  display_name: state_key,

  avatar: null,

  attribution: null,

  source: { Room: { room_id: '!r:x', state_key } },

  images: [image('a', ['Sticker']), image('b', ['Emoticon']), image('c', [])],

  editable,

  enabled_everywhere: false

});

test('shortcodes come from file names and never clash', () => {

  const taken = new Set(['cat']);

  assert.equal(shortcodeFor('Cat.PNG', taken), 'cat_2');

  assert.equal(shortcodeFor('my cool sticker!.webp', taken), 'my_cool_sticker');

  assert.equal(shortcodeFor('.png', taken), 'image');

  assert.equal(packSlug('Cats & Dogs'), 'cats-dogs');

});

test('stickers include images with no usage of their own', () => {

  assert.deepEqual(stickersOf(roomPack('s', true)).map((i) => i.shortcode), ['a', 'c']);

});

test('custom reaction nicknames fall back to known packs without changing the reaction key', () => {

  const packs = [roomPack('mine', true)];

  assert.equal(reactionShortcode('mxc://x/a', undefined, packs), 'a');

  assert.equal(reactionShortcode('mxc://x/a', ' preferred ', packs), 'preferred');

  assert.equal(reactionShortcode('mxc://x/unknown', undefined, packs), undefined);

  assert.equal(reactionShortcode('👍', 'thumbsup', packs), undefined);

});

test('sticker commands resolve names without matching emoticons or choosing ambiguous stickers', () => {

  const pack = roomPack('s', true);

  assert.equal(findSticker([pack], 'A').sticker.shortcode, 'a');

  assert.equal(findSticker([pack], 'c').pack, pack);

  assert.throws(() => findSticker([pack], 'b'), /No sticker named b/);

  assert.throws(() => findSticker([pack], 'missing'), /No sticker named missing/);

  assert.throws(() => findSticker([pack, roomPack('other', false)], 'a'), /More than one sticker/);

});

test('your pack is always a destination, then editable room packs only', () => {

  const packs = { global: [], rooms: { '!r:x': [roomPack('mine', true), roomPack('theirs', false)] } };

  const choices = editableChoices(packs, () => 'Room');

  assert.deepEqual(choices.map((c) => c.target), [{ kind: 'user' }, { kind: 'room', room_id: '!r:x', state_key: 'mine' }]);

  const dests = clonePackDestinations(roomPack('Fancy Pack', false), [{ room_id: '!d:x', name: 'Dest' }], () => 'Room');

  assert.deepEqual(dests[1].target, { kind: 'room', room_id: '!d:x', state_key: 'fancy-pack' });

});

test('new pack names avoid existing keys without changing merge destinations', () => {

  const packs = { global: [], rooms: { '!r:x': [roomPack('cats', true), roomPack('cats-2', true)] } };

  assert.equal(freePackStateKey(packs, '!r:x', 'Cats'), 'cats-3');

  assert.equal(freePackStateKey(packs, '!other:x', 'Cats'), 'cats');

  const destination = editableChoices(packs, () => 'Room')[1];

  const request = cloneRequest({ kind: 'pack', pack: roomPack('source', false) }, destination.target, ['Sticker', 'Emoticon'], null, destination.pack);

  assert.deepEqual(request, { op: 'clone_pack', from_pack: 'room:!r:x:source', to: destination.target, display_name: null, usage: ['Sticker', 'Emoticon'] });

});

test('image and event clones keep explicit usage and event names avoid collisions', () => {

  const pack = roomPack('source', false);

  const to = { kind: 'user' as const };

  assert.deepEqual(cloneRequest({ kind: 'image', pack, image: pack.images[1] }, to, ['Sticker'], null, null), {

    op: 'clone_pack_image', from_pack: pack.id, shortcode: 'b', to, usage: ['Sticker']

  });

  const source = { kind: 'sticker' as const, room_id: '!r:x', event_id: '$event', body: 'a' };

  assert.deepEqual(cloneRequest(source, to, ['Sticker', 'Emoticon'], null, pack), {

    op: 'clone_sticker', room_id: '!r:x', event_id: '$event', shortcode: 'a_2', to, usage: ['Sticker', 'Emoticon']

  });

  assert.throws(() => cloneRequest(source, to, [], null, pack), /at least one use/);

});

test('channel packs include all ancestor spaces once and do not cross to unrelated spaces', () => {

  const local = roomPack('local', false);

  const parent = { ...roomPack('parent', false), id: 'space-pack' };

  const ancestor = { ...roomPack('ancestor', false), id: 'ancestor-pack' };

  const unrelated = { ...roomPack('unrelated', false), id: 'unrelated-pack' };

  const global = { ...roomPack('global', false), id: 'global-pack' };

  const packs = { global: [global, parent], rooms: { '!r:x': [local], '!s:x': [parent], '!a:x': [ancestor], '!u:x': [unrelated] } };

  const rooms = [

    { room_id: '!r:x', parent_spaces: ['!s:x'], children: [], space: false },

    { room_id: '!s:x', parent_spaces: ['!a:x'], children: ['!r:x'], space: true },

    { room_id: '!a:x', parent_spaces: ['!s:x'], children: ['!s:x'], space: true },

    { room_id: '!u:x', parent_spaces: [], children: [], space: true }

  ];

  assert.deepEqual(packsForRoom(packs, '!r:x', rooms).map((pack) => pack.id), [local.id, parent.id, ancestor.id, global.id]);

  assert.deepEqual(packsForRoom(packs, '!r:x', [{ ...rooms[0], parent_spaces: [] }, ...rooms.slice(1)]).map((pack) => pack.id), [local.id, parent.id, ancestor.id, global.id]);

});