forked from Blendman974/faceclaw
241 lines
13 KiB
JavaScript
241 lines
13 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const vm = require('node:vm');
|
|
const ts = require('typescript');
|
|
|
|
function fixture(store = new Map()) {
|
|
const storage = { getStringSetting: (key, fallback) => store.get(key) ?? fallback,
|
|
setStringSetting: (key, value) => store.set(key, value), onSettingsStoreChanged() {},
|
|
getBooleanSetting: (_key, fallback) => fallback, setBooleanSetting() {} };
|
|
function load(file, deps, suffix = '') {
|
|
const context = { exports: {}, global: { isIOS: false }, console,
|
|
require: id => deps(id) };
|
|
vm.runInNewContext(ts.transpileModule(fs.readFileSync(file, 'utf8') + suffix, {
|
|
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
|
}).outputText, context);
|
|
return context.exports;
|
|
}
|
|
const layout = load('app/apps/launcher/launcher-layout.ts', () => storage);
|
|
const folders = load('app/apps/launcher/launcher-folders.ts', id => id === './launcher-layout' ? layout : storage);
|
|
const settings = load('app/ui/dashboard-settings.ts', id => {
|
|
if (id.includes('settings-store')) return storage;
|
|
if (id.includes('transcription-language')) return require('../.test-build/app/native/transcription-language.js');
|
|
if (id.includes('brightness-curve')) return require('../.test-build/app/g2/brightness-curve.js');
|
|
if (id.includes('animation-speed')) return require('../.test-build/app/ui/animation-speed.js');
|
|
return { Layer: class {}, ASSISTANT_MODEL_CHOICES: [] };
|
|
});
|
|
return { store, layout, folders, settings, load };
|
|
}
|
|
const plain = value => JSON.parse(JSON.stringify(value));
|
|
|
|
test('legacy assignments and alphabetical default survive creation, rename and restart', () => {
|
|
const f = fixture();
|
|
const original = plain(f.folders.getFolderAssignments());
|
|
assert.equal(f.settings.launcherLayoutSetting.get(), 'alphabetical');
|
|
assert.equal(f.folders.createFolder(' Français '), true);
|
|
assert.deepEqual(plain(f.folders.getFolders().get('Français')), []);
|
|
assert.deepEqual(plain(f.folders.getFolderAssignments()), original);
|
|
assert.equal(f.folders.renameFolder('Games', 'Jeux'), true);
|
|
const again = fixture(f.store);
|
|
assert.equal(again.folders.getFolderAssignments().blocks, 'Jeux');
|
|
assert.equal(again.folders.getFolderAssignments().calculator, 'Prototypes');
|
|
assert.equal(again.folders.getFolders().has('Français'), true);
|
|
assert.equal(again.folders.getFolders().has('Games'), false);
|
|
});
|
|
|
|
test('folder names reject blank, multiline, long and case-insensitive duplicate names', () => {
|
|
const f = fixture();
|
|
for (const name of ['', ' ', 'games', 'GAMES', 'x'.repeat(25), 'Two\nlines']) {
|
|
assert.equal(f.folders.createFolder(name), false, name);
|
|
assert.equal(f.folders.renameFolder('Prototypes', name), false, name);
|
|
}
|
|
assert.equal(f.folders.renameFolder('Games', 'games'), true);
|
|
assert.equal(f.folders.renameFolder('missing', 'New name'), false);
|
|
});
|
|
|
|
test('explicit empty folders persist, can be deleted and never reintroduce default assignments', () => {
|
|
const f = fixture(new Map([['launcher.folders', '{}']]));
|
|
assert.equal(f.folders.createFolder('Empty'), true);
|
|
f.folders.setAppFolder('test', 'Empty');
|
|
f.folders.setAppFolder('test', null);
|
|
assert.equal(fixture(f.store).folders.getFolders().has('Empty'), true);
|
|
assert.equal(f.folders.disbandFolder('Empty'), 0);
|
|
assert.equal(f.folders.getFolders().size, 0);
|
|
assert.equal(f.folders.unusedNewFolderName(), 'New folder');
|
|
f.folders.createFolder('New folder');
|
|
assert.equal(f.folders.unusedNewFolderName(), 'New folder 2');
|
|
});
|
|
|
|
test('deleting a non-empty folder ungroups all members without losing other assignments', () => {
|
|
const f = fixture();
|
|
assert.equal(f.folders.disbandFolder('Games'), 5);
|
|
assert.equal(f.folders.getFolderAssignments().blocks, undefined);
|
|
assert.equal(f.folders.getFolderAssignments().calculator, 'Prototypes');
|
|
assert.equal(fixture(f.store).folders.getFolders().has('Games'), false);
|
|
});
|
|
|
|
test('custom root and folder orders persist independently, survive renames and append new apps', () => {
|
|
const f = fixture();
|
|
const entries = [{ label: 'Alpha', id: 'app:a' }, { label: 'Beta', id: 'app:b' }, { label: 'Games', id: 'folder:Games' }];
|
|
const sort = (scope, custom = true) => plain(f.layout.orderLauncherEntries(entries.slice(), e => e.id, scope, custom)).map(e => e.id);
|
|
f.settings.launcherLayoutSetting.set('custom');
|
|
f.layout.moveLauncherEntry(null, entries.map(e => e.id), 'folder:Games', 'app:a');
|
|
f.layout.setLauncherOrder('Games', ['app:b', 'app:a']);
|
|
assert.deepEqual(sort(null), ['folder:Games', 'app:a', 'app:b']);
|
|
assert.deepEqual(sort('Games'), ['app:b', 'app:a', 'folder:Games']);
|
|
assert.deepEqual(sort(null, false), ['app:a', 'app:b', 'folder:Games']);
|
|
f.settings.launcherLayoutSetting.set('alphabetical');
|
|
f.settings.launcherLayoutSetting.set('custom');
|
|
assert.deepEqual(sort(null), ['folder:Games', 'app:a', 'app:b']);
|
|
f.folders.renameFolder('Games', 'Jeux');
|
|
const again = fixture(f.store);
|
|
assert.equal(again.settings.launcherLayoutSetting.get(), 'custom');
|
|
entries[2] = { label: 'Jeux', id: 'folder:Jeux' };
|
|
assert.deepEqual(sort(null), ['folder:Jeux', 'app:a', 'app:b']);
|
|
assert.deepEqual(sort('Jeux'), ['app:b', 'app:a', 'folder:Jeux']);
|
|
entries.push({ label: 'A newly installed app', id: 'app:new' });
|
|
assert.deepEqual(sort(null), ['folder:Jeux', 'app:a', 'app:b', 'app:new']);
|
|
f.folders.disbandFolder('Jeux');
|
|
f.folders.createFolder('Jeux');
|
|
assert.deepEqual(sort('Jeux'), ['app:new', 'app:a', 'app:b', 'folder:Jeux']);
|
|
});
|
|
|
|
test('malformed metadata is safe; moves tolerate removed apps and stale IDs', () => {
|
|
const f = fixture(new Map([['launcher.folderNames', '{bad'], ['launcher.order', '{bad']]));
|
|
assert.equal(f.folders.getExplicitFolderNames().length, 0);
|
|
assert.equal(f.layout.moveLauncherEntry(null, ['a', 'b'], 'missing', 'a'), false);
|
|
assert.equal(f.layout.moveLauncherEntry(null, ['a', 'b'], 'a', 'missing'), false);
|
|
assert.equal(f.layout.moveLauncherEntry(null, ['a', 'b'], 'a', 'b'), true);
|
|
assert.deepEqual(JSON.parse(f.store.get('launcher.order')).root, ['b', 'a']);
|
|
});
|
|
|
|
function launcherFixture() {
|
|
const f = fixture(new Map([['launcher.folders', '{}']]));
|
|
const layers = [], launches = [], deleted = [];
|
|
class IconGrid {
|
|
constructor(options) { this.options = options; this.index = null; }
|
|
get selectedItem() { return this.index === null ? null : this.options.items()[this.index] ?? null; }
|
|
resetSelection() { this.index = null; }
|
|
selectIndex(index) { this.index = index; }
|
|
enterRowMode() { this.index = null; }
|
|
async handleInput(event, ctx) {
|
|
if (event.type === 'click') await this.options.onActivate(this.selectedItem, ctx);
|
|
if (event.type === 'double-click' || event.type === 'swipe-left') this.options.onBack(ctx);
|
|
}
|
|
}
|
|
class MenuLayer { constructor(title, items) { this.title = title; this.items = items; } }
|
|
class EditTextSettingLayer { constructor(setting) { this.setting = setting; } }
|
|
let edit;
|
|
const ctx = { stack: {
|
|
push: layer => layers.push(layer), pop() { const layer = layers.pop(); layer?.onRemoved?.(); },
|
|
popIfTop(test) { if (layers.length && test(layers.at(-1))) { this.pop(); return true; } return false; },
|
|
}, actions: { requestRender() {}, endTextSettingEdit() {}, startTextSettingsEdit(settings, title, submit, toggle, cancel) {
|
|
edit = { setting: settings[0], submit, cancel };
|
|
} } };
|
|
const api = f.load('app/apps/launcher/launcher-app.ts', id => {
|
|
if (id === './launcher-folders') return f.folders;
|
|
if (id === './launcher-layout') return f.layout;
|
|
if (id.endsWith('/dashboard-settings')) return { ...f.settings, EditTextSettingLayer,
|
|
enumSettingMenuItem: setting => ({ label: setting.label }) };
|
|
if (id.endsWith('/icon-grid')) return { IconGrid, ICON_GRID_BAND_INSET_X: 0, ICON_GRID_HIGHLIGHT_INSET_Y: 0 };
|
|
if (id.endsWith('/menu')) return { MenuLayer };
|
|
if (id.endsWith('/shell/shell')) return { shell: { yieldFocusToSidebar() {} } };
|
|
return {};
|
|
}, '\nexport { LauncherGridLayer };');
|
|
const apps = [{ appId: 'a', label: 'Alpha', icon: 'a' }, { appId: 'b', label: 'Beta', icon: 'b' }, { appId: 'c', label: 'Gamma', icon: 'c' }];
|
|
const layer = new api.LauncherGridLayer({ apps: () => apps, launchApp: id => launches.push(id), uninstallApp: id => deleted.push(id) });
|
|
return { ...f, layer, ctx, layers, launches, deleted, apps, edit: () => edit,
|
|
choose(label) { const item = layer.menuItems().find(item => item.label === label); assert.ok(item, label); item.onSelect(ctx); } };
|
|
}
|
|
|
|
test('launcher menu is available in row mode and supports empty folder creation and entry', async () => {
|
|
const h = launcherFixture();
|
|
assert.deepEqual(plain(h.layer.menuItems().map(item => item.label)), ['Layout', 'New folder']);
|
|
h.choose('New folder');
|
|
const folder = h.layer.entries().find(entry => entry.kind === 'folder');
|
|
assert.equal(folder.name, 'New folder');
|
|
await h.layer.openEntry(folder);
|
|
assert.equal(h.layer.currentFolder, 'New folder');
|
|
assert.equal(h.layer.entries().length, 0);
|
|
assert.ok(h.layer.menuItems().some(item => item.label === 'Rename folder'));
|
|
});
|
|
|
|
test('folder rename uses the existing editor, commits on submit only, and preserves open folder', async () => {
|
|
const h = launcherFixture(); h.choose('New folder');
|
|
await h.layer.openEntry(h.layer.entries().find(entry => entry.kind === 'folder'));
|
|
h.choose('Rename folder');
|
|
h.edit().setting.set('Renommé');
|
|
assert.equal(h.layer.menuItems().length, 0);
|
|
assert.equal(h.folders.getFolders().has('New folder'), true);
|
|
h.edit().cancel();
|
|
assert.equal(h.folders.getFolders().has('Renommé'), false);
|
|
h.choose('Rename folder');
|
|
h.edit().setting.set('Renommé');
|
|
h.edit().submit();
|
|
assert.equal(h.layer.currentFolder, 'Renommé');
|
|
assert.equal(h.folders.getFolders().has('New folder'), false);
|
|
assert.equal(h.layers.length, 0);
|
|
});
|
|
|
|
test('moving icons reorders without launching; cancellation and alphabetical mode preserve order', async () => {
|
|
const h = launcherFixture();
|
|
h.layer.grid.selectIndex(0);
|
|
assert.equal(h.layer.menuItems().some(item => item.label === 'Move icon'), false);
|
|
h.settings.launcherLayoutSetting.set('custom');
|
|
h.choose('Move icon');
|
|
h.layer.grid.selectIndex(2);
|
|
await h.layer.handleInput({ type: 'click' }, h.ctx);
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['b', 'c', 'a']);
|
|
assert.equal(h.launches.length, 0);
|
|
h.choose('Move icon');
|
|
h.layer.grid.selectIndex(0);
|
|
await h.layer.handleInput({ type: 'double-click' }, h.ctx);
|
|
assert.equal(h.layer.moving, null);
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['b', 'c', 'a']);
|
|
h.settings.launcherLayoutSetting.set('alphabetical');
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['a', 'b', 'c']);
|
|
h.settings.launcherLayoutSetting.set('custom');
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['b', 'c', 'a']);
|
|
});
|
|
|
|
test('folder moves stay inside their scope, folder deletion is confirmed and apps are not uninstalled', async () => {
|
|
const h = launcherFixture(); h.folders.createFolder('Dossier');
|
|
h.folders.setAppFolder('a', 'Dossier'); h.folders.setAppFolder('b', 'Dossier');
|
|
await h.layer.openEntry(h.layer.entries().find(entry => entry.kind === 'folder'));
|
|
h.settings.launcherLayoutSetting.set('custom'); h.layer.grid.selectIndex(0);
|
|
h.choose('Move icon'); await h.layer.openEntry(h.layer.entries()[1]);
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['b', 'a']);
|
|
h.choose('Delete folder');
|
|
assert.equal(h.folders.getFolders().has('Dossier'), true);
|
|
h.layers.at(-1).items[0].onSelect(h.ctx);
|
|
assert.equal(h.folders.getFolders().has('Dossier'), false);
|
|
assert.equal(h.layer.currentFolder, null);
|
|
assert.equal(h.layer.entries().length, 3);
|
|
assert.equal(h.deleted.length, 0);
|
|
});
|
|
|
|
|
|
test('legacy folders with removed apps disappear while explicit empty folders remain', async () => {
|
|
const h = launcherFixture();
|
|
h.folders.setAppFolder('a', 'Legacy');
|
|
await h.layer.openEntry(h.layer.entries().find(entry => entry.kind === 'folder'));
|
|
h.apps.splice(0, 1);
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['b', 'c']);
|
|
assert.equal(h.layer.currentFolder, null);
|
|
h.folders.createFolder('Empty');
|
|
await h.layer.openEntry(h.layer.entries().find(entry => entry.kind === 'folder'));
|
|
assert.equal(h.layer.entries().length, 0);
|
|
assert.equal(h.layer.currentFolder, 'Empty');
|
|
});
|
|
|
|
test('removing the source during a move cancels without launching or corrupting order', async () => {
|
|
const h = launcherFixture(); h.settings.launcherLayoutSetting.set('custom');
|
|
h.layer.grid.selectIndex(0); h.choose('Move icon');
|
|
h.apps.splice(0, 1);
|
|
await h.layer.openEntry(h.layer.entries()[0]);
|
|
assert.equal(h.layer.moving, null);
|
|
assert.equal(h.launches.length, 0);
|
|
assert.deepEqual(plain(h.layer.entries().map(entry => entry.appId)), ['b', 'c']);
|
|
});
|