@axium/client 0.36.7 → 0.37.0

package/dist/cli/cache.d.ts

@@ -39,6 +39,7 @@ export declare const meta: Handle<z.ZodObject<{
             emailVerified: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
             preferences: z.ZodLazy<z.ZodObject<{
                 debug: z.ZodDefault<z.ZodBoolean>;
+                theme: z.ZodDefault<z.ZodLiteral<"default" | "light" | "forest" | "midnight" | "beach" | "cherry" | "volcano">>;
             }, z.core.$strip>>;
             roles: z.ZodArray<z.ZodString>;
             tags: z.ZodArray<z.ZodString>;

package/dist/cli/cache.js

@@ -6,6 +6,7 @@ import { dirname, join, resolve } from 'node:path/posix';
 import * as z from 'zod';
 import { CacheData } from '../cache.js';
 import { fetchAPI } from '../requests.js';
+import { applyDiff } from '../sync.js';
 import { apiUserCache, getCurrentSession } from '../user.js';
 export const dir = join(process.env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'axium');
 mkdirSync(dir, { recursive: true });
@@ -90,20 +91,8 @@ export const sync = useAt({
         if (!sync)
             return await fetchAPI('GET', 'sync/init');
         const diff = await fetchAPI('GET', 'sync', { since: sync.index });
-        const deleted = new Set(diff.deleted);
-        const objects = sync.objects.filter(o => !deleted.has(o.id));
-        const existing = Object.fromEntries(objects.map(o => [o.id, o]));
-        for (const obj of diff.created)
-            objects.push(obj);
-        for (const updated of diff.updated) {
-            const base = existing[updated.id];
-            if (!base)
-                throw new ReferenceError("Can not update object because it isn't cached");
-            if (base.$type !== updated.$type)
-                throw new ReferenceError(`Type mismatch whilst updating cache object: currently ${base.$type}, incoming ${updated.$type}`);
-            Object.assign(base, updated);
-        }
-        return { objects, index: diff.index };
+        applyDiff(sync.objects, diff);
+        return { objects: sync.objects, index: diff.index };
     },
     async isValid({ index }) {
         const md = await fetchAPI('GET', 'sync/metadata');

package/dist/cli/config.d.ts

@@ -13,6 +13,7 @@ export declare function session(): {
         username: string;
         preferences: {
             debug: boolean;
+            theme: "default" | "light" | "forest" | "midnight" | "beach" | "cherry" | "volcano";
         };
         roles: string[];
         tags: string[];

package/dist/cli/config.js

@@ -1,3 +1,4 @@
+import { persistFeaturesTo } from '@axium/core/node/features';
 import { loadPlugin } from '@axium/core/node/plugins';
 import * as io from 'ioium/node';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
@@ -11,6 +12,7 @@ mkdirSync(configDir, { recursive: true });
 export const axcConfigPath = join(configDir, 'config.json');
 if (!existsSync(axcConfigPath))
     writeFileSync(axcConfigPath, '{}');
+persistFeaturesTo(join(configDir, 'features.json'));
 export function session() {
     if (!config.token)
         io.exit('Not logged in.', 4);

package/dist/cli/sync.d.ts

@@ -1,4 +1,5 @@
-import type { ZodObject, ZodUUID } from 'zod';
+import { schemas } from '../sync.js';
+export { schemas };
 export interface $Objects {
 }
 export type ObjectType = keyof $Objects extends never ? string : keyof $Objects;
@@ -9,9 +10,5 @@ type ObjectValues = keyof $Objects extends never ? Record<string, {
         id: string;
     })[];
 };
-export declare function useSchema<Type extends ObjectType, S extends ZodObject<{
-    id: ZodUUID;
-}>>(type: Type, schema: S): void;
 export declare function get<Type extends ObjectType>(type: Type): ObjectValues[Type];
 export declare function save<Type extends ObjectType>(type: Type, objects: ObjectValues[Type]): void;
-export {};

package/dist/cli/sync.js

@@ -1,13 +1,11 @@
+import { schemas } from '../sync.js';
 import { sync as syncCache } from './cache.js';
+export { schemas };
 let _byType;
 function byType() {
     _byType ||= Object.groupBy(syncCache.data.objects, o => o.$type);
     return _byType;
 }
-const schemas = new Map();
-export function useSchema(type, schema) {
-    schemas.set(type, schema);
-}
 export function get(type) {
     const value = byType()[type] || [];
     const schema = schemas.get(type);

package/dist/locales.d.ts

@@ -1,263 +1,4 @@
-import type { FlattenKeys, GetByString, Split, UnionToIntersection } from 'utilium';
-/**
- * Add translations to a locale.
- * Note that translations are rendered as HTML, only replacements are escaped.
- */
-export declare function extendLocale(locale: string, data: object): void;
-declare let currentLoaded: {
-    readonly AccessControlDialog: {
-        readonly named_title: "Permissions for <strong>{name}</strong>";
-        readonly owner: "Owner";
-        readonly title: "Permissions";
-        readonly remove: "Remove";
-        readonly toast_removed: "Removed access";
-        readonly public_target: "Everyone";
-        readonly add_public: "Add Public Access";
-        readonly placeholder: "Add users and roles";
-    };
-    readonly AppMenu: {
-        readonly failed: "Couldn't load apps.";
-        readonly none: "No apps available.";
-    };
-    readonly AppPreferences: {
-        readonly title: "Preferences for {name}";
-        readonly save: "Save";
-        readonly toast_saved: "Preferences saved";
-        readonly dialog_toggle: "Settings";
-    };
-    readonly Discovery: {
-        readonly no_results: "No results";
-    };
-    readonly Login: {
-        readonly register: "Register instead";
-    };
-    readonly Logout: {
-        readonly back: "Take me back";
-        readonly question: "Are you sure you want to log out?";
-    };
-    readonly Register: {
-        readonly login: "Login instead";
-    };
-    readonly SessionList: {
-        readonly created: "Created {date}";
-        readonly current: "Current";
-        readonly elevated: "Elevated";
-        readonly expires: "Expires {date}";
-        readonly logout_all_question: "Are you sure you want to log out all sessions?";
-        readonly logout_all_submit: "Logout All Sessions";
-        readonly logout_all_trigger: "Logout All";
-        readonly logout_single: "Are you sure you want to log out this session?";
-    };
-    readonly Upload: {
-        readonly upload: "Upload";
-    };
-    readonly UserCard: {
-        readonly you: "(You)";
-    };
-    readonly UserMenu: {
-        readonly account: "Your Account";
-        readonly admin: "Administration";
-    };
-    readonly Version: {
-        readonly error: "Latest unknown";
-        readonly latest: "Latest";
-        readonly upgrade: "<span class=\"version\">{latest}</span> available";
-    };
-    readonly ZodInput: {
-        readonly invalid_type: "Invalid input type: {type}";
-    };
-    readonly generic: {
-        readonly action_irreversible: "This action can't be undone.";
-        readonly cancel: "Cancel";
-        readonly change: "Change";
-        readonly create: "Create";
-        readonly delete: "Delete";
-        readonly done: "Done";
-        readonly email: "Email";
-        readonly loading: "Loading...";
-        readonly login: "Login";
-        readonly logout: "Logout";
-        readonly no: "No";
-        readonly none: "None";
-        readonly ok: "Okay";
-        readonly preferences: "Preferences";
-        readonly recovery: "Recovery";
-        readonly recovery_method_disabled: "This recovery method is disabled and can't be used.";
-        readonly register: "Register";
-        readonly rename: "Rename";
-        readonly sessions: "Sessions";
-        readonly share: "Share";
-        readonly success: "Success";
-        readonly unknown: "Unknown";
-        readonly unnamed: "Unnamed";
-        readonly user_display_name: "Display name";
-        readonly username: "Username";
-        readonly yes: "Yes";
-    };
-    readonly page: {
-        readonly account: {
-            readonly delete_account: "Delete Account";
-            readonly delete_account_confirm: "Are you sure you want to delete your account?";
-            readonly edit_email: "Email Address";
-            readonly edit_name: "What do you want to be called?";
-            readonly edit_username: "Pick a unique username";
-            readonly email_verified_on: "Email verified on {date}";
-            readonly greeting: "Welcome, {name}";
-            readonly passkeys: {
-                readonly backed_up: "This passkey is backed up";
-                readonly create: "Create";
-                readonly created: "Created {date}";
-                readonly delete: "Delete";
-                readonly delete_confirm: "Are you sure you want to delete this passkey?";
-                readonly edit_name: "Passkey Name";
-                readonly min_one: "You must have at least one passkey";
-                readonly multi_device: "Multiple devices";
-                readonly name_type_error: "Passkey name must be a string";
-                readonly not_backed_up: "This passkey is not backed up";
-                readonly rename: "Rename";
-                readonly single_device: "Single device";
-                readonly title: "Passkeys";
-            };
-            readonly personal_info: "Personal Information";
-            readonly pfp: {
-                readonly update: "Upload";
-                readonly remove: "Remove";
-                readonly toast_removed: "Profile picture removed";
-                readonly toast_updated: "Profile picture updated";
-            };
-            readonly preferences: "Preferences";
-            readonly remove_email: "Remove email";
-            readonly remove_email_confirm: "Are you sure you want to remove your recovery email?";
-            readonly sessions: "Sessions";
-            readonly title: "Your Account";
-            readonly toast_username_updated: "Username updated";
-            readonly user_id: "User ID";
-            readonly user_id_hint: "This is your UUID. It can't be changed.";
-            readonly verification_sent: "Verification email sent";
-            readonly verify: "Verify";
-        };
-        readonly admin: {
-            readonly heading: "Administration";
-            readonly tab: {
-                readonly dashboard: "Dashboard";
-                readonly users: "Users";
-                readonly config: "Configuration";
-                readonly plugins: "Plugins";
-                readonly audit: "Audit Log";
-            };
-            readonly toast: {
-                readonly suspended: "User suspended";
-                readonly unsuspended: "User un-suspended";
-                readonly user_updated: "User updated";
-            };
-            readonly audit: {
-                readonly any: "Any";
-                readonly apply: "Apply";
-                readonly error_stack: "Error Stack";
-                readonly event_heading: "Audit Event";
-                readonly event_title: "Admin — Audit Log Event #{id}";
-                readonly extra_data: "Extra Data";
-                readonly filter: {
-                    readonly event: "Event Name:";
-                    readonly severity: "Minimum Severity:";
-                    readonly since: "Since:";
-                    readonly source: "Source:";
-                    readonly tags: "Tags:";
-                    readonly until: "Until:";
-                    readonly user: "User UUID:";
-                };
-                readonly filters: "Filters";
-                readonly heading: "Audit Log";
-                readonly invalid_filter: "Invalid Filter:";
-                readonly name: "Name";
-                readonly no_events: "No audit log events found";
-                readonly reset: "Reset";
-                readonly severity: "Severity";
-                readonly source: "Source";
-                readonly tags: "Tags";
-                readonly timestamp: "Timestamp";
-                readonly title: "Admin — Audit Log";
-                readonly user: "User";
-                readonly uuid: "UUID";
-            };
-            readonly config: {
-                readonly active: "Active Configuration";
-                readonly loaded_files: "Loaded Files";
-                readonly title: "Admin — Configuration";
-            };
-            readonly dashboard: {
-                readonly audit_link: "Audit Log";
-                readonly config_files: "{count} files loaded.";
-                readonly config_link: "Configuration";
-                readonly plugins_link: "Plugins";
-                readonly plugins_loaded: "{count} plugins loaded.";
-                readonly stats: "{users} users, {sessions} sessions, {passkeys} passkeys.";
-                readonly title: "Admin — Dashboard";
-                readonly users_link: "Users";
-            };
-            readonly plugins: {
-                readonly author: "Author:";
-                readonly configuration: "Configuration";
-                readonly heading: "Plugins";
-                readonly loaded_from: "Loaded from";
-                readonly none: "No plugins loaded.";
-                readonly provided_apps: "Provided apps:";
-                readonly title: "Admin — Plugins";
-            };
-            readonly users: {
-                readonly admin_tag: "Admin";
-                readonly administrator: "Administrator";
-                readonly attributes: "Attributes";
-                readonly audit: "Audit";
-                readonly back: "Back to all users";
-                readonly create: "Create User";
-                readonly created_title: "New User Created";
-                readonly created_url: "They can log in using this URL:";
-                readonly default_image: "Default";
-                readonly delete_confirm: "Are you sure you want to delete this user?";
-                readonly delete_user: "Delete User";
-                readonly display_name: "Display Name";
-                readonly email_not_verified: "not verified";
-                readonly email_verified: "verified {date}";
-                readonly heading: "Users";
-                readonly manage: "Manage";
-                readonly manage_heading: "User Management";
-                readonly manage_title: "Admin — User Management";
-                readonly none: "No users!";
-                readonly profile_image: "Profile Image";
-                readonly registered: "Registered";
-                readonly roles: "Roles";
-                readonly suspend: "Suspend";
-                readonly suspended: "Suspended";
-                readonly tags: "Tags";
-                readonly title: "Admin — Users";
-                readonly unsuspend: "Unsuspend";
-                readonly uuid: "UUID";
-            };
-        };
-        readonly login: {
-            readonly client: {
-                readonly authorize: "Authorize";
-                readonly confirm: "Are you sure you want to log in to this local client?";
-                readonly success: "Login successful! You can close this tab.";
-                readonly title: "Local Client Login";
-            };
-            readonly failed: "Login Failed";
-        };
-    };
-    readonly location: {
-        readonly country: "Country";
-        readonly subdivision: "State / province";
-        readonly locality: "City / town";
-        readonly postal_code: "Postal code";
-        readonly street1: "Street address";
-        readonly street2: "Street address line 2";
-    };
-    readonly audit_severity: readonly ["Emergency", "Alert", "Critical", "Error", "Warning", "Notice", "Info", "Debug"];
-    readonly preference: {
-        readonly debug: "Debug mode";
-    };
-};
+import { type LocaleKey, type LocaleKeys, type LocaleValue } from '@axium/core/locales';
 /**
  * Current locale
  */
@@ -267,20 +8,12 @@ export declare function dateField(name: string): string | undefined;
 export declare function conjoin(list: Iterable<string>): string;
 export declare function disjoin(list: Iterable<string>): string;
 export declare let currentMonthNames: string[];
-type _locale = typeof currentLoaded;
-export interface Locale extends _locale {
-}
 export interface ReplacementOptions {
     $default?: string;
     /** Whether to treat the replacement as HTML */
     $html?: boolean;
 }
-type _ArgsValue<V extends string[]> = UnionToIntersection<{
-    [I in keyof V]: Split<V[I], '}'> extends [infer Name extends string, string] ? {
-        [N in Name]: string | number | bigint | boolean;
-    } : {};
-}[keyof V & number]>;
-type Replacements<K extends string> = ReplacementOptions & (GetByString<Locale, K> extends string ? _ArgsValue<Split<GetByString<Locale, K> & string, '{'>> : Record<string, any>);
+type Replacements<K extends string> = ReplacementOptions & (K extends LocaleKey ? LocaleKeys[K & LocaleKey] : Record<string, LocaleValue>);
 type ReplacementsArgs<K extends string> = {} extends Replacements<K> ? [replacements?: Replacements<K>] : [replacements: Replacements<K>];
 export declare function useLocale(newLocale: string): void;
 export declare function escape(text: string): string;
@@ -291,5 +24,5 @@ export declare function escape(text: string): string;
  * text(`example.translation.key.${dynamicPart}`, { a: 1, b: 2 });
  * ```
  */
-export declare function text<const K extends string = FlattenKeys<Locale>>(key: K, ...args: ReplacementsArgs<K>): string;
+export declare function text<const K extends string = LocaleKey>(key: K, ...args: ReplacementsArgs<K>): string;
 export {};

package/dist/locales.js

@@ -1,21 +1,9 @@
-import { debug, error, info, warn } from 'ioium';
-import { deepAssign, getByString } from 'utilium';
+import { extendLocale, loadedLocales } from '@axium/core/locales';
+import { error, warn } from 'ioium';
 import en from '../locales/en.json' with { type: 'json' };
-const loadedLocales = Object.assign(Object.create(null), { en });
-/**
- * Add translations to a locale.
- * Note that translations are rendered as HTML, only replacements are escaped.
- */
-export function extendLocale(locale, data) {
-    if (!loadedLocales[locale]) {
-        info('Adding new locale (no built-in): ' + locale);
-        loadedLocales[locale] = {};
-    }
-    else
-        debug('Extending locale: ' + locale);
-    deepAssign(loadedLocales[locale], data);
-}
-let currentLoaded = en;
+import { getByString } from 'utilium';
+extendLocale('en', en);
+let currentLoaded;
 /**
  * Current locale
  */

package/dist/socket.js

@@ -5,12 +5,11 @@ import { origin, token, userAgent } from './requests.js';
 const listeners = new Set();
 export function addListener(event, listener) {
     const schema = ServerToClient[event];
-    if (schema)
-        listeners.add([event, schema.implement(listener)]);
-    else {
+    if (!schema)
         io.warn(`Attaching a listener to the '${event}' socket event without schema`);
-        listeners.add([event, listener]);
-    }
+    const entry = [event, schema ? schema.implement(listener) : listener];
+    listeners.add(entry);
+    socket?.on(...entry);
 }
 export let socket = null;
 export function connect(opts) {

package/dist/sync.d.ts

@@ -0,0 +1,22 @@
+import type { SyncDiff, SyncDiffObject } from '@axium/core';
+import type { ZodObject, ZodUUID } from 'zod';
+/** Schemas used to parse synced objects, by object type */
+export declare const schemas: Map<string, ZodObject<{
+    id: ZodUUID;
+}, import("@axium/client").$strip>>;
+/** Parse a synced object using the schema for its type. Objects without a schema are passed through. */
+export declare function parseObject<T extends SyncDiffObject>(object: SyncDiffObject): T;
+/**
+ *  Apply a diff to some synced objects, updating them in place.
+ * Existing objects are updated in place, so bound references stay valid.
+ */
+export declare function applyDiff<T extends {
+    id: string;
+    $type?: string;
+}>(objects: T[], diff: SyncDiff, type?: string): void;
+/**
+ * Handle changes to synced objects pushed by the server.
+ * The socket must be connected for these to be received.
+ * @returns a function that removes the listener
+ */
+export declare function onSync(listener: (diff: SyncDiff) => void): () => void;

package/dist/sync.js

@@ -0,0 +1,67 @@
+import * as io from 'ioium';
+import { addListener } from './socket.js';
+/** Schemas used to parse synced objects, by object type */
+export const schemas = new Map();
+/** Parse a synced object using the schema for its type. Objects without a schema are passed through. */
+export function parseObject(object) {
+    const schema = schemas.get(object.$type);
+    if (!schema)
+        return object;
+    return Object.assign(schema.parse(object), { $type: object.$type });
+}
+/**
+ *  Apply a diff to some synced objects, updating them in place.
+ * Existing objects are updated in place, so bound references stay valid.
+ */
+export function applyDiff(objects, diff, type) {
+    const deleted = new Set(diff.deleted);
+    for (let i = objects.length - 1; i >= 0; i--) {
+        if (deleted.has(objects[i].id))
+            objects.splice(i, 1);
+    }
+    const existing = new Map(objects.map(object => [object.id, object]));
+    for (const incoming of [...diff.created, ...diff.updated]) {
+        if (type && incoming.$type != type)
+            continue;
+        let object;
+        try {
+            object = parseObject(incoming);
+        }
+        catch (e) {
+            io.warn(`Ignoring invalid ${incoming.$type} object from sync: ${io.errorText(e)}`);
+            continue;
+        }
+        const current = existing.get(incoming.id);
+        if (!current) {
+            objects.push(object);
+            existing.set(object.id, object);
+            continue;
+        }
+        if (current.$type && current.$type != incoming.$type) {
+            io.warn(`Type mismatch for synced object ${incoming.id}: currently ${current.$type}, incoming ${incoming.$type}`);
+            continue;
+        }
+        Object.assign(current, object);
+    }
+}
+const listeners = new Set();
+/**
+ * Handle changes to synced objects pushed by the server.
+ * The socket must be connected for these to be received.
+ * @returns a function that removes the listener
+ */
+export function onSync(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+addListener('sync', diff => {
+    io.debug(`sync: ${diff.created.length} created, ${diff.updated.length} updated, ${diff.deleted.length} deleted`);
+    for (const listener of listeners) {
+        try {
+            listener(diff);
+        }
+        catch (e) {
+            io.error('Sync listener failed: ' + io.errorText(e));
+        }
+    }
+});

package/dist/themes.d.ts

@@ -0,0 +1,2 @@
+import type { Theme } from '@axium/core/preferences';
+export declare const themeStyles: Record<Theme, Record<string, string>>;

package/dist/themes.js

@@ -0,0 +1,34 @@
+export const themeStyles = Object.assign(Object.create(null), {
+    light: {
+        'fg-light': '10%',
+        'bg-light': '70%',
+        'light-step': '-6%',
+    },
+    forest: {
+        hue: '150',
+        'fg-light': '75%',
+        'bg-light': '20%',
+    },
+    midnight: {
+        'fg-light': '60%',
+        'bg-light': '2.5%',
+        'light-step': '2.5%',
+    },
+    beach: {
+        hue: '50',
+        'fg-light': '30%',
+        'bg-light': '60%',
+        'light-step': '-4%',
+    },
+    cherry: {
+        hue: '330',
+        'fg-light': '80%',
+        'bg-light': '20%',
+    },
+    volcano: {
+        hue: '10',
+        'fg-light': '80%',
+        'bg-light': '10%',
+        'light-step': '5%',
+    },
+});

package/dist/user.d.ts

@@ -10,6 +10,7 @@ export declare function loginByUsername(username: string): Promise<NewSessionRes
 export declare function getCurrentSession(): Promise<Session & {
     user: User;
 }>;
+export declare function extendCurrentSession(userId: string): Promise<void>;
 export declare function getSessions(userId: string): Promise<Session[]>;
 export declare function logout(userId: string, ...sessionId: string[]): Promise<Session[]>;
 export declare function logoutAll(userId: string): Promise<Session[]>;

package/dist/user.js

@@ -25,6 +25,11 @@ export async function getCurrentSession() {
     _currentSession ||= await fetchAPI('GET', 'session');
     return _currentSession;
 }
+export async function extendCurrentSession(userId) {
+    const optionsJSON = await fetchAPI('PUT', 'users/:id/auth', { type: 'extend_session' }, userId);
+    const response = await startAuthentication({ optionsJSON });
+    await fetchAPI('POST', 'users/:id/auth', response, userId);
+}
 export async function getSessions(userId) {
     _checkId(userId);
     return await fetchAPI('GET', 'users/:id/sessions', {}, userId);

package/dist/web/features.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Browser-side feature state.
+ *
+ * Enabled feature IDs are listed in a single `feature` attribute on `<html>`, so CSS selects them with the `~=` operator
+ *
+ * @example
+ * ```css
+ * [feature~='checkbox-switch'] {
+ * 	input[type='checkbox'] { ... }
+ * }
+ * ```
+ *
+ * @module
+ */
+export declare function loadFeatures(userId?: string): Promise<void>;
+export declare function setUserFeatures(userId: string, update: Record<string, boolean>): Promise<Record<string, boolean>>;
+export declare function setGlobalFeatures(update: Record<string, boolean>): Promise<Record<string, boolean>>;

package/dist/web/features.js

@@ -0,0 +1,47 @@
+/**
+ * Browser-side feature state.
+ *
+ * Enabled feature IDs are listed in a single `feature` attribute on `<html>`, so CSS selects them with the `~=` operator
+ *
+ * @example
+ * ```css
+ * [feature~='checkbox-switch'] {
+ * 	input[type='checkbox'] { ... }
+ * }
+ * ```
+ *
+ * @module
+ */
+import { getAll, set, use } from '@axium/core/features';
+import { fetchAPI } from '../requests.js';
+function _setFeatureAttributes() {
+    const enabled = getAll()
+        .filter(f => f.value)
+        .map(f => f.id)
+        .toArray();
+    if (enabled.length)
+        document.documentElement.setAttribute('feature', enabled.join(' '));
+    else
+        document.documentElement.removeAttribute('feature');
+}
+export async function loadFeatures(userId) {
+    const features = userId
+        ? await fetchAPI('GET', 'users/:id/features', {}, userId).catch(() => fetchAPI('GET', 'features'))
+        : await fetchAPI('GET', 'features');
+    use(features);
+    _setFeatureAttributes();
+}
+export async function setUserFeatures(userId, update) {
+    const values = await fetchAPI('POST', 'users/:id/features', update, userId);
+    for (const [id, value] of Object.entries(values))
+        set(id, value);
+    _setFeatureAttributes();
+    return values;
+}
+export async function setGlobalFeatures(update) {
+    const values = await fetchAPI('POST', 'features', update);
+    for (const [id, value] of Object.entries(values))
+        set(id, value);
+    _setFeatureAttributes();
+    return values;
+}