@joewinke/jatui 0.27.1 → 0.28.0

package/dist/sound/names.js

@@ -0,0 +1,121 @@
+/**
+ * Semantic sound names — what an app SAYS ("confirm", "incoming-call"), not
+ * which file it plays. Each name carries the policy facts the preferences
+ * layer needs: its category, a base volume, whether it is essential (survives
+ * the quiet/reduced-motion preference), and how it loops.
+ *
+ * Hosts can re-point any name at their own file (`player.register('incoming-call',
+ * '/ringer.mp3')`) and can register names of their own; unknown names fall back
+ * to `CUSTOM_SOUND_SPEC` (a non-essential UI sound).
+ */
+export const SOUND_CATEGORIES = ['ui', 'notifications', 'calls'];
+export const SOUND_NAMES = [
+    'confirm',
+    'error',
+    'notify',
+    'message',
+    'send',
+    'toggle',
+    'tap',
+    'incoming-call'
+];
+export const SOUND_SPECS = {
+    confirm: {
+        category: 'ui',
+        volume: 0.15,
+        essential: false,
+        loop: false,
+        loopGapMs: 0,
+        description: 'An important action succeeded (saved, paid, published)'
+    },
+    error: {
+        category: 'ui',
+        volume: 0.2,
+        essential: true,
+        loop: false,
+        loopGapMs: 0,
+        description: 'An action failed'
+    },
+    notify: {
+        category: 'notifications',
+        volume: 0.3,
+        essential: false,
+        loop: false,
+        loopGapMs: 0,
+        description: 'Something happened the user did not cause'
+    },
+    message: {
+        category: 'notifications',
+        volume: 0.3,
+        essential: false,
+        loop: false,
+        loopGapMs: 0,
+        description: 'A message arrived from another person'
+    },
+    send: {
+        category: 'ui',
+        volume: 0.15,
+        essential: false,
+        loop: false,
+        loopGapMs: 0,
+        description: 'The user sent a message or submitted a form'
+    },
+    toggle: {
+        category: 'ui',
+        volume: 0.12,
+        essential: false,
+        loop: false,
+        loopGapMs: 0,
+        description: 'A switch changed state'
+    },
+    tap: {
+        category: 'ui',
+        volume: 0.1,
+        essential: false,
+        loop: false,
+        loopGapMs: 0,
+        description: 'A deliberate, low-frequency press'
+    },
+    'incoming-call': {
+        category: 'calls',
+        volume: 0.5,
+        essential: true,
+        loop: true,
+        loopGapMs: 1200,
+        description: 'Someone is calling — rings until answered or declined'
+    }
+};
+/** Spec for a host-registered name that is not one of the semantic names. */
+export const CUSTOM_SOUND_SPEC = {
+    category: 'ui',
+    volume: 0.15,
+    essential: false,
+    loop: false,
+    loopGapMs: 0,
+    description: 'Host-registered sound'
+};
+/** Pre-semantic clip names (utils/sound.ts era) mapped to their semantic spec. */
+const LEGACY_ALIASES = { success: 'confirm', pop: 'tap' };
+export function isSoundName(name) {
+    return SOUND_NAMES.includes(name);
+}
+export function soundSpecFor(name) {
+    if (isSoundName(name))
+        return SOUND_SPECS[name];
+    const alias = LEGACY_ALIASES[name];
+    return alias ? SOUND_SPECS[alias] : CUSTOM_SOUND_SPEC;
+}
+/**
+ * The bundled CC0 clip for each semantic name, loaded on first use so apps
+ * that never play a sound never ship the base64 payloads in their entry chunk.
+ */
+export const BUILTIN_CLIPS = {
+    confirm: () => import('../assets/sounds/success').then((m) => m.successSound),
+    error: () => import('../assets/sounds/error').then((m) => m.errorSound),
+    notify: () => import('../assets/sounds/notify').then((m) => m.notifySound),
+    message: () => import('../assets/sounds/notify').then((m) => m.notifySound),
+    send: () => import('../assets/sounds/send').then((m) => m.sendSound),
+    toggle: () => import('../assets/sounds/toggle').then((m) => m.toggleSound),
+    tap: () => import('../assets/sounds/pop').then((m) => m.popSound),
+    'incoming-call': () => import('../assets/sounds/notify').then((m) => m.notifySound)
+};

package/dist/sound/player.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The sound player — semantic names in, policy-gated audio out.
+ *
+ *   const sound = getSoundPlayer()
+ *   sound.play('confirm')
+ *   await sound.register('incoming-call', '/sounds/ringer.mp3', { loopGapMs: 0 })
+ *   const ring = sound.play('incoming-call')   // loops
+ *   ring.stop()                                 // answered / declined
+ *
+ * `play` is synchronous and never throws: a sound that is blocked, missing or
+ * still decoding returns a handle anyway (`handle.blocked` says why it is
+ * silent). Looping sounds are re-checked whenever preferences change, so
+ * turning sound off or muting "calls" silences a ringing call immediately.
+ */
+import { type SoundBackend } from './backend';
+import { type SoundBlockReason, type SoundEnvironment } from './policy';
+import { type SoundPreferencesStore } from './preferences';
+import { type SoundCategory, type SoundName, type SoundSpec } from './names';
+/** A semantic name, or any name the host registered itself. */
+export type SoundId = SoundName | (string & {});
+export interface PlaySoundOptions {
+    /** Base gain 0–1, replacing the spec's (still scaled by master volume). */
+    volume?: number;
+    category?: SoundCategory;
+    essential?: boolean;
+    loop?: boolean;
+    /**
+     * Explicit user test (a "Preview" button in settings): bypasses every gate
+     * except master volume. Never use it for app-triggered sounds.
+     */
+    preview?: boolean;
+}
+export interface SoundHandle {
+    stop(): void;
+    /** True while audible or still decoding toward audible. */
+    readonly playing: boolean;
+    /** Why it is silent, when the policy blocked it. */
+    readonly blocked: SoundBlockReason | null;
+}
+export interface SoundPlayer {
+    /** Point a name at a clip (data URI or URL) and decode it. */
+    register(name: SoundId, src: string, spec?: Partial<SoundSpec>): Promise<void>;
+    play(name: SoundId, options?: PlaySoundOptions): SoundHandle;
+    /** Decode clips ahead of time (defaults to every semantic name). */
+    preload(names?: readonly SoundId[]): Promise<void>;
+    stopAll(): void;
+    destroy(): void;
+}
+export interface CreateSoundPlayerOptions {
+    preferences?: SoundPreferencesStore;
+    environment?: () => SoundEnvironment;
+    backend?: SoundBackend;
+}
+export declare function createSoundPlayer(options?: CreateSoundPlayerOptions): SoundPlayer;
+/** The app-wide player, bound to the shared preferences store. */
+export declare function getSoundPlayer(): SoundPlayer;
+/** Test seam: replace (or with no argument, drop) the shared player. */
+export declare function setSoundPlayer(player: SoundPlayer | null): void;
+/** Shorthand for `getSoundPlayer().play(name, options)`. */
+export declare function playSound(name: SoundId, options?: PlaySoundOptions): SoundHandle;

package/dist/sound/player.js

@@ -0,0 +1,141 @@
+/**
+ * The sound player — semantic names in, policy-gated audio out.
+ *
+ *   const sound = getSoundPlayer()
+ *   sound.play('confirm')
+ *   await sound.register('incoming-call', '/sounds/ringer.mp3', { loopGapMs: 0 })
+ *   const ring = sound.play('incoming-call')   // loops
+ *   ring.stop()                                 // answered / declined
+ *
+ * `play` is synchronous and never throws: a sound that is blocked, missing or
+ * still decoding returns a handle anyway (`handle.blocked` says why it is
+ * silent). Looping sounds are re-checked whenever preferences change, so
+ * turning sound off or muting "calls" silences a ringing call immediately.
+ */
+import { createWebAudioBackend } from './backend';
+import { decideSound, readSoundEnvironment } from './policy';
+import { getSoundPreferences } from './preferences';
+import { BUILTIN_CLIPS, isSoundName, SOUND_NAMES, soundSpecFor } from './names';
+export function createSoundPlayer(options = {}) {
+    const prefs = options.preferences ?? getSoundPreferences();
+    const environment = options.environment ?? readSoundEnvironment;
+    let backend = options.backend ?? null;
+    const entries = new Map();
+    const active = new Set();
+    const audio = () => (backend ??= createWebAudioBackend());
+    function clipFor(name) {
+        let entry = entries.get(name);
+        if (!entry)
+            entries.set(name, (entry = { spec: {} }));
+        if (!entry.clip) {
+            const src = entry.src
+                ? Promise.resolve(entry.src)
+                : isSoundName(name)
+                    ? BUILTIN_CLIPS[name]().catch(() => null)
+                    : Promise.resolve(null);
+            entry.clip = src.then((s) => (s ? audio().load(s) : null));
+        }
+        return entry.clip;
+    }
+    // Looping voices (ringers) obey preference changes while they play.
+    const unsubscribe = prefs.subscribe((p) => {
+        for (const a of [...active]) {
+            if (!a.spec.loop)
+                continue;
+            if (!decideSound(p, a.spec, environment()).play)
+                a.handle.stop();
+        }
+    });
+    function silent(reason) {
+        return { stop() { }, playing: false, blocked: reason };
+    }
+    return {
+        async register(name, src, spec = {}) {
+            entries.set(name, { spec, src });
+            await clipFor(name);
+        },
+        play(name, opts = {}) {
+            const base = { ...soundSpecFor(name), ...(entries.get(name)?.spec ?? {}) };
+            const spec = {
+                ...base,
+                volume: opts.volume ?? base.volume,
+                category: opts.category ?? base.category,
+                essential: opts.essential ?? base.essential,
+                loop: opts.loop ?? base.loop
+            };
+            const p = prefs.get();
+            let gain;
+            if (opts.preview) {
+                gain = Math.min(1, Math.max(0, spec.volume)) * p.volume;
+                if (gain <= 0)
+                    return silent('silent');
+            }
+            else {
+                const d = decideSound(p, spec, environment());
+                if (!d.play)
+                    return silent(d.reason);
+                gain = d.gain;
+            }
+            let voice = null;
+            let playing = true;
+            const record = {
+                spec,
+                handle: {
+                    stop() {
+                        if (!playing)
+                            return;
+                        playing = false;
+                        active.delete(record);
+                        voice?.stop();
+                    },
+                    get playing() {
+                        return playing;
+                    },
+                    blocked: null
+                }
+            };
+            active.add(record);
+            clipFor(name).then((clip) => {
+                if (!playing)
+                    return;
+                voice = clip
+                    ? audio().start(clip, {
+                        gain,
+                        loop: spec.loop,
+                        loopGapMs: spec.loopGapMs,
+                        onEnded: () => record.handle.stop()
+                    })
+                    : null;
+                if (!voice)
+                    record.handle.stop();
+            });
+            return record.handle;
+        },
+        async preload(names = SOUND_NAMES) {
+            await Promise.all(names.map((n) => clipFor(n)));
+        },
+        stopAll() {
+            for (const a of [...active])
+                a.handle.stop();
+        },
+        destroy() {
+            unsubscribe();
+            for (const a of [...active])
+                a.handle.stop();
+        }
+    };
+}
+let shared = null;
+/** The app-wide player, bound to the shared preferences store. */
+export function getSoundPlayer() {
+    return (shared ??= createSoundPlayer());
+}
+/** Test seam: replace (or with no argument, drop) the shared player. */
+export function setSoundPlayer(player) {
+    shared?.destroy();
+    shared = player;
+}
+/** Shorthand for `getSoundPlayer().play(name, options)`. */
+export function playSound(name, options) {
+    return getSoundPlayer().play(name, options);
+}

package/dist/sound/policy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The sound policy — a pure function from (preferences, sound, environment) to
+ * "play at this gain" or "don't, because …". Every play goes through it, and
+ * because it is pure the whole discipline is unit-testable without audio.
+ */
+import type { SoundCategory } from './names';
+import type { QuietHours, SoundPreferences } from './preferences';
+export interface SoundEnvironment {
+    /** The document is hidden (background tab, minimized window). */
+    hidden: boolean;
+    /** `prefers-reduced-motion: reduce` is set at the OS level. */
+    reducedMotion: boolean;
+    now: Date;
+}
+export interface SoundRequest {
+    category: SoundCategory;
+    essential: boolean;
+    /** Base gain 0–1 (the spec volume or the caller's override). */
+    volume: number;
+}
+export type SoundBlockReason = 'disabled' | 'category-muted' | 'hidden' | 'quiet-hours' | 'quiet' | 'silent';
+export type SoundDecision = {
+    play: true;
+    gain: number;
+} | {
+    play: false;
+    reason: SoundBlockReason;
+    gain: 0;
+};
+/** Is `now` inside the window? `start > end` wraps midnight; `start == end` is empty. */
+export declare function inQuietHours(quietHours: QuietHours | null, now: Date): boolean;
+export declare function decideSound(prefs: SoundPreferences, req: SoundRequest, env: SoundEnvironment): SoundDecision;
+/** Read the live browser environment; on the server everything is "quiet". */
+export declare function readSoundEnvironment(): SoundEnvironment;

package/dist/sound/policy.js

@@ -0,0 +1,56 @@
+/**
+ * The sound policy — a pure function from (preferences, sound, environment) to
+ * "play at this gain" or "don't, because …". Every play goes through it, and
+ * because it is pure the whole discipline is unit-testable without audio.
+ */
+function minutes(hhmm) {
+    const [h, m] = hhmm.split(':').map(Number);
+    return h * 60 + m;
+}
+/** Is `now` inside the window? `start > end` wraps midnight; `start == end` is empty. */
+export function inQuietHours(quietHours, now) {
+    if (!quietHours)
+        return false;
+    const s = minutes(quietHours.start);
+    const e = minutes(quietHours.end);
+    const t = now.getHours() * 60 + now.getMinutes();
+    if (s === e)
+        return false;
+    return s < e ? t >= s && t < e : t >= s || t < e;
+}
+export function decideSound(prefs, req, env) {
+    const no = (reason) => ({ play: false, reason, gain: 0 });
+    // Calls are opt-out; everything else is opt-in behind the master switch.
+    // A ringer that is silent out of the box is a missed call.
+    if (req.category !== 'calls' && !prefs.enabled)
+        return no('disabled');
+    if (!prefs.categories[req.category])
+        return no('category-muted');
+    // Calls are the one category that must reach a user who is looking elsewhere.
+    if (req.category !== 'calls') {
+        if (env.hidden)
+            return no('hidden');
+        if (inQuietHours(prefs.quietHours, env.now))
+            return no('quiet-hours');
+    }
+    if (req.category === 'ui' && !req.essential) {
+        if (prefs.quiet === 'on' || (prefs.quiet === 'auto' && env.reducedMotion))
+            return no('quiet');
+    }
+    const gain = Math.min(1, Math.max(0, req.volume)) * prefs.volume;
+    return gain > 0 ? { play: true, gain } : no('silent');
+}
+/** Read the live browser environment; on the server everything is "quiet". */
+export function readSoundEnvironment() {
+    const now = new Date();
+    if (typeof document === 'undefined')
+        return { hidden: true, reducedMotion: false, now };
+    let reducedMotion = false;
+    try {
+        reducedMotion = !!globalThis.matchMedia?.('(prefers-reduced-motion: reduce)').matches;
+    }
+    catch {
+        // matchMedia unavailable — treat as no preference
+    }
+    return { hidden: document.visibilityState === 'hidden', reducedMotion, now };
+}

package/dist/sound/preferences.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Sound preferences — the ONE store every app sound goes through.
+ *
+ * Framework-free (subscribe/get/set) so it works in plain TS, node tests and
+ * Svelte alike; `SoundSettings.svelte` is a thin view over it. Persisted per
+ * device in localStorage, SSR-safe (no storage → in-memory defaults), synced
+ * across tabs via the `storage` event, and tolerant of corrupt/partial JSON.
+ *
+ * UI and notification sounds are OFF by default (opt-in); calls are ON by
+ * default (opt-out) so an incoming call rings out of the box. A device that set the pre-0.28 boolean
+ * (`jatui-sound-enabled`) is migrated on first read.
+ */
+import { type SoundCategory } from './names';
+/** Local wall-clock window, 'HH:MM' 24h. `start > end` wraps midnight. */
+export interface QuietHours {
+    start: string;
+    end: string;
+}
+/**
+ * Non-essential UI sounds (taps, toggles, confirms):
+ * - `auto` — silenced when the OS asks for reduced motion
+ * - `on`   — always silenced
+ * - `off`  — never silenced by this preference
+ */
+export type SoundQuietMode = 'auto' | 'on' | 'off';
+export interface SoundPreferences {
+    /** Master switch for `ui` + `notifications` (opt-in). Calls ignore it — mute them via `categories.calls`. */
+    enabled: boolean;
+    /** Master volume 0–1, multiplied into every sound's base gain. */
+    volume: number;
+    /** Per-category switch — `false` mutes that category. */
+    categories: Record<SoundCategory, boolean>;
+    /** Everything except calls is silent inside this window. `null` = off. */
+    quietHours: QuietHours | null;
+    quiet: SoundQuietMode;
+}
+export declare const SOUND_PREFS_STORAGE_KEY = "jatui-sound-prefs";
+/** The pre-semantic boolean key from utils/sound.ts — read once to migrate. */
+export declare const LEGACY_SOUND_ENABLED_KEY = "jatui-sound-enabled";
+export declare const DEFAULT_SOUND_PREFERENCES: SoundPreferences;
+/** Coerce anything (parsed JSON, a partial patch) into a complete, valid object. */
+export declare function normalizeSoundPreferences(raw: unknown, base?: SoundPreferences): SoundPreferences;
+export type SoundPreferencesPatch = Partial<Omit<SoundPreferences, 'categories'>> & {
+    categories?: Partial<Record<SoundCategory, boolean>>;
+};
+export interface SoundPreferencesStore {
+    get(): SoundPreferences;
+    /** Merge a patch (categories merge per key) and persist. */
+    set(patch: SoundPreferencesPatch | ((current: SoundPreferences) => SoundPreferencesPatch)): void;
+    setCategory(category: SoundCategory, on: boolean): void;
+    reset(): void;
+    /** Calls `fn` immediately and on every change; returns the unsubscribe. */
+    subscribe(fn: (prefs: SoundPreferences) => void): () => void;
+    /** Drop the cross-tab listener. */
+    destroy(): void;
+}
+/** Minimal Storage surface — `localStorage`, `sessionStorage` or a test fake. */
+export type SoundPreferencesStorage = Pick<Storage, 'getItem' | 'setItem'>;
+export interface CreateSoundPreferencesOptions {
+    /** Defaults to `globalThis.localStorage` when present; `null` = memory only. */
+    storage?: SoundPreferencesStorage | null;
+    key?: string;
+    /** Overrides applied over the library defaults for a device with nothing saved. */
+    defaults?: SoundPreferencesPatch;
+}
+export declare function createSoundPreferences(options?: CreateSoundPreferencesOptions): SoundPreferencesStore;
+/** The app-wide store (lazy, so SSR imports never touch storage). */
+export declare function getSoundPreferences(): SoundPreferencesStore;
+/** Test seam: replace (or with no argument, drop) the shared store. */
+export declare function setSoundPreferences(store: SoundPreferencesStore | null): void;

package/dist/sound/preferences.js

@@ -0,0 +1,145 @@
+/**
+ * Sound preferences — the ONE store every app sound goes through.
+ *
+ * Framework-free (subscribe/get/set) so it works in plain TS, node tests and
+ * Svelte alike; `SoundSettings.svelte` is a thin view over it. Persisted per
+ * device in localStorage, SSR-safe (no storage → in-memory defaults), synced
+ * across tabs via the `storage` event, and tolerant of corrupt/partial JSON.
+ *
+ * UI and notification sounds are OFF by default (opt-in); calls are ON by
+ * default (opt-out) so an incoming call rings out of the box. A device that set the pre-0.28 boolean
+ * (`jatui-sound-enabled`) is migrated on first read.
+ */
+import { SOUND_CATEGORIES } from './names';
+export const SOUND_PREFS_STORAGE_KEY = 'jatui-sound-prefs';
+/** The pre-semantic boolean key from utils/sound.ts — read once to migrate. */
+export const LEGACY_SOUND_ENABLED_KEY = 'jatui-sound-enabled';
+export const DEFAULT_SOUND_PREFERENCES = Object.freeze({
+    enabled: false,
+    volume: 1,
+    categories: Object.freeze({ ui: true, notifications: true, calls: true }),
+    quietHours: null,
+    quiet: 'auto'
+});
+const TIME_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
+function clampVolume(v, fallback) {
+    const n = typeof v === 'number' ? v : Number.NaN;
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(1, Math.max(0, n));
+}
+/** Coerce anything (parsed JSON, a partial patch) into a complete, valid object. */
+export function normalizeSoundPreferences(raw, base = DEFAULT_SOUND_PREFERENCES) {
+    const r = (raw && typeof raw === 'object' ? raw : {});
+    const cats = (r.categories && typeof r.categories === 'object' ? r.categories : {});
+    const categories = {};
+    for (const c of SOUND_CATEGORIES) {
+        categories[c] = typeof cats[c] === 'boolean' ? cats[c] : base.categories[c];
+    }
+    let quietHours = base.quietHours;
+    if (r.quietHours === null)
+        quietHours = null;
+    else if (r.quietHours && typeof r.quietHours === 'object') {
+        const q = r.quietHours;
+        if (typeof q.start === 'string' && typeof q.end === 'string' && TIME_RE.test(q.start) && TIME_RE.test(q.end)) {
+            quietHours = { start: q.start, end: q.end };
+        }
+    }
+    return {
+        enabled: typeof r.enabled === 'boolean' ? r.enabled : base.enabled,
+        volume: clampVolume(r.volume, base.volume),
+        categories,
+        quietHours,
+        quiet: r.quiet === 'auto' || r.quiet === 'on' || r.quiet === 'off' ? r.quiet : base.quiet
+    };
+}
+function defaultStorage() {
+    try {
+        return typeof localStorage === 'undefined' ? null : localStorage;
+    }
+    catch {
+        return null; // access can throw (sandboxed iframe, blocked cookies)
+    }
+}
+function merge(current, patch) {
+    return normalizeSoundPreferences({ ...current, ...patch, categories: { ...current.categories, ...(patch.categories ?? {}) } }, current);
+}
+export function createSoundPreferences(options = {}) {
+    const storage = options.storage === undefined ? defaultStorage() : options.storage;
+    const key = options.key ?? SOUND_PREFS_STORAGE_KEY;
+    const defaults = merge(DEFAULT_SOUND_PREFERENCES, options.defaults ?? {});
+    const listeners = new Set();
+    function read() {
+        if (!storage)
+            return defaults;
+        try {
+            const raw = storage.getItem(key);
+            if (raw != null)
+                return normalizeSoundPreferences(JSON.parse(raw), defaults);
+            if (storage.getItem(LEGACY_SOUND_ENABLED_KEY) === 'true')
+                return { ...defaults, enabled: true };
+        }
+        catch {
+            // corrupt JSON or a throwing storage — fall back to defaults
+        }
+        return defaults;
+    }
+    let current = read();
+    function emit() {
+        for (const fn of listeners)
+            fn(current);
+    }
+    function commit(next) {
+        current = next;
+        if (storage) {
+            try {
+                storage.setItem(key, JSON.stringify(next));
+            }
+            catch {
+                // quota / private mode — keep the in-memory value
+            }
+        }
+        emit();
+    }
+    const onStorage = (e) => {
+        if (e.key !== key)
+            return;
+        current = read();
+        emit();
+    };
+    const crossTab = storage != null && typeof window !== 'undefined' && storage === defaultStorage();
+    if (crossTab)
+        window.addEventListener('storage', onStorage);
+    return {
+        get: () => current,
+        set(patch) {
+            commit(merge(current, typeof patch === 'function' ? patch(current) : patch));
+        },
+        setCategory(category, on) {
+            commit(merge(current, { categories: { [category]: on } }));
+        },
+        reset() {
+            commit(defaults);
+        },
+        subscribe(fn) {
+            listeners.add(fn);
+            fn(current);
+            return () => listeners.delete(fn);
+        },
+        destroy() {
+            listeners.clear();
+            if (crossTab)
+                window.removeEventListener('storage', onStorage);
+        }
+    };
+}
+let shared = null;
+/** The app-wide store (lazy, so SSR imports never touch storage). */
+export function getSoundPreferences() {
+    return (shared ??= createSoundPreferences());
+}
+/** Test seam: replace (or with no argument, drop) the shared store. */
+export function setSoundPreferences(store) {
+    shared?.destroy();
+    shared = store;
+}