@streamscloud/kit 0.1.3 → 0.1.5

package/dist/core/locale/app-locale.svelte.d.ts

@@ -0,0 +1,16 @@
+import { type AppLocaleValue } from './types';
+declare class AppLocaleContainer {
+    private _current;
+    get current(): AppLocaleValue;
+    get availableLocales(): readonly AppLocaleValue[];
+    init: (serverLocale?: AppLocaleValue) => void;
+    /**
+     * Change locale.
+     * In the browser: persists to cookie and reloads the page (wuchale translations are compile-time).
+     * On the server / in non-browser contexts: updates the reactive state directly.
+     */
+    change: (newLocale: AppLocaleValue) => void;
+    toggle: () => void;
+}
+export declare const AppLocale: AppLocaleContainer;
+export {};

package/dist/core/locale/app-locale.svelte.js

@@ -0,0 +1,36 @@
+import { isBrowser } from '../utils';
+import { LocaleCookie } from './locale-cookie';
+import { APP_LOCALE_DEFAULT, APP_LOCALE_VALUES } from './types';
+class AppLocaleContainer {
+    _current = $state(APP_LOCALE_DEFAULT);
+    get current() {
+        return this._current;
+    }
+    get availableLocales() {
+        return APP_LOCALE_VALUES;
+    }
+    init = (serverLocale) => {
+        this._current = serverLocale ?? LocaleCookie.get() ?? APP_LOCALE_DEFAULT;
+    };
+    /**
+     * Change locale.
+     * In the browser: persists to cookie and reloads the page (wuchale translations are compile-time).
+     * On the server / in non-browser contexts: updates the reactive state directly.
+     */
+    change = (newLocale) => {
+        if (newLocale === this._current) {
+            return;
+        }
+        if (!isBrowser()) {
+            this._current = newLocale;
+            return;
+        }
+        LocaleCookie.set(newLocale);
+        window.location.reload();
+    };
+    toggle = () => {
+        const currentIndex = APP_LOCALE_VALUES.indexOf(this._current);
+        this.change(APP_LOCALE_VALUES[(currentIndex + 1) % APP_LOCALE_VALUES.length]);
+    };
+}
+export const AppLocale = new AppLocaleContainer();

package/dist/core/locale/index.d.ts

@@ -0,0 +1,4 @@
+export { AppLocale } from './app-locale.svelte';
+export { LocaleCookie } from './locale-cookie';
+export { APP_LOCALE_COOKIE, APP_LOCALE_DEFAULT, APP_LOCALE_VALUES, getLocaleFromAcceptLanguage, isValidLocale } from './types';
+export type { AppLocaleValue, LocalizationSchema } from './types';

package/dist/core/locale/index.js

@@ -0,0 +1,3 @@
+export { AppLocale } from './app-locale.svelte';
+export { LocaleCookie } from './locale-cookie';
+export { APP_LOCALE_COOKIE, APP_LOCALE_DEFAULT, APP_LOCALE_VALUES, getLocaleFromAcceptLanguage, isValidLocale } from './types';

package/dist/core/locale/locale-cookie.d.ts

@@ -0,0 +1,5 @@
+import { type AppLocaleValue } from './types';
+export declare const LocaleCookie: {
+    get: () => AppLocaleValue | null;
+    set: (value: AppLocaleValue) => void;
+};

package/dist/core/locale/locale-cookie.js

@@ -0,0 +1,19 @@
+import { isBrowser } from '../utils';
+import { APP_LOCALE_COOKIE, APP_LOCALE_VALUES } from './types';
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 365; // 1 year
+export const LocaleCookie = {
+    get: () => {
+        if (!isBrowser()) {
+            return null;
+        }
+        const match = document.cookie.match(new RegExp(`${APP_LOCALE_COOKIE}=([^;]+)`));
+        const value = match?.[1];
+        return APP_LOCALE_VALUES.find((locale) => locale === value) ?? null;
+    },
+    set: (value) => {
+        if (!isBrowser()) {
+            return;
+        }
+        document.cookie = `${APP_LOCALE_COOKIE}=${value};path=/;max-age=${COOKIE_MAX_AGE};SameSite=Lax`;
+    }
+};

package/dist/core/locale/types.d.ts

@@ -0,0 +1,9 @@
+export declare const APP_LOCALE_COOKIE = "app-locale";
+export declare const APP_LOCALE_VALUES: readonly ["en", "no"];
+export declare const APP_LOCALE_DEFAULT: "en";
+export type AppLocaleValue = (typeof APP_LOCALE_VALUES)[number];
+export type LocalizationSchema = {
+    [key: string]: Record<AppLocaleValue, unknown>;
+};
+export declare const isValidLocale: (value: string | undefined) => value is AppLocaleValue;
+export declare const getLocaleFromAcceptLanguage: (header: string | null) => AppLocaleValue | null;

package/dist/core/locale/types.js

@@ -0,0 +1,25 @@
+export const APP_LOCALE_COOKIE = 'app-locale';
+export const APP_LOCALE_VALUES = ['en', 'no'];
+export const APP_LOCALE_DEFAULT = 'en';
+export const isValidLocale = (value) => {
+    return APP_LOCALE_VALUES.some((locale) => locale === value);
+};
+export const getLocaleFromAcceptLanguage = (header) => {
+    if (!header) {
+        return null;
+    }
+    // Parse Accept-Language: en-US,en;q=0.9,no;q=0.8
+    const languages = header.split(',').map((lang) => lang.split(';')[0].trim());
+    for (const lang of languages) {
+        const found = APP_LOCALE_VALUES.find((locale) => locale === lang);
+        if (found) {
+            return found;
+        }
+        const base = lang.split('-')[0];
+        const baseFound = APP_LOCALE_VALUES.find((locale) => locale === base);
+        if (baseFound) {
+            return baseFound;
+        }
+    }
+    return null;
+};

package/dist/core/toastr/toastr.svelte.js

@@ -2,25 +2,22 @@ import { ToasterHost } from './toaster-host.svelte';
 export class Toastr {
     static async error(message, options) {
         const toast = await ToasterHost.ensure();
-        toast.error(message, patchOptions(options));
+        toast.error(message, options);
     }
     static async success(message, options) {
         const toast = await ToasterHost.ensure();
-        toast.success(message, patchOptions(options));
+        toast.success(message, options);
     }
     static async warning(message, options) {
         const toast = await ToasterHost.ensure();
-        toast.warning(message, patchOptions(options));
+        toast.warning(message, options);
     }
     static async info(message, options) {
         const toast = await ToasterHost.ensure();
-        toast.info(message, patchOptions(options));
+        toast.info(message, options);
     }
     static async promise(promise, messages) {
         const toast = await ToasterHost.ensure();
         toast.promise(promise, messages);
     }
 }
-const patchOptions = (options) => {
-    return { ...options, duration: 100000 };
-};

package/dist/core/utils/compact-number.d.ts

@@ -1,8 +1,8 @@
-import { type Locale } from '../../locale';
+import { type AppLocaleValue } from '../locale';
 type CompactOptions = {
     decimals?: number;
     trimZeros?: boolean;
-    locale?: Locale;
+    locale?: AppLocaleValue;
 };
 export declare const compactNumber: (value: number, options?: CompactOptions) => string;
 export {};

package/dist/core/utils/compact-number.js

@@ -1,10 +1,10 @@
-import { getLocale } from '../../locale';
+import { AppLocale } from '../locale';
 const THOUSAND = 1_000;
 const MILLION = 1_000_000;
 const BILLION = 1_000_000_000;
 const TRILLION = 1_000_000_000_000;
 export const compactNumber = (value, options = {}) => {
-    const { decimals = 1, trimZeros = true, locale = getLocale() } = options;
+    const { decimals = 1, trimZeros = true, locale = AppLocale.current } = options;
     const abs = Math.abs(value);
     const formatter = makeNumberFormatter(locale, decimals, trimZeros);
     if (abs >= TRILLION) {

package/dist/core/validation/validation-schemas/validation-localization.js

@@ -1,25 +1,25 @@
-import { getLocale } from '../../../locale';
+import { AppLocale } from '../../locale';
 export class ValidationLocalization {
     get required() {
-        return loc.required[getLocale()];
+        return loc.required[AppLocale.current];
     }
     get email() {
-        return loc.email[getLocale()];
+        return loc.email[AppLocale.current];
     }
     get minLength() {
-        return loc.minLength[getLocale()];
+        return loc.minLength[AppLocale.current];
     }
     get maxLength() {
-        return loc.maxLength[getLocale()];
+        return loc.maxLength[AppLocale.current];
     }
     get min() {
-        return loc.min[getLocale()];
+        return loc.min[AppLocale.current];
     }
     get max() {
-        return loc.max[getLocale()];
+        return loc.max[AppLocale.current];
     }
     get badFormat() {
-        return loc.badFormat[getLocale()];
+        return loc.badFormat[AppLocale.current];
     }
 }
 const loc = {

package/dist/ui/line-clamp/line-clamp-localization.js

@@ -1,10 +1,10 @@
-import { getLocale } from '../../locale';
+import { AppLocale } from '../../core/locale';
 export class LineClampLocalization {
     get showLess() {
-        return loc.showLess[getLocale()];
+        return loc.showLess[AppLocale.current];
     }
     get showMore() {
-        return loc.showMore[getLocale()];
+        return loc.showMore[AppLocale.current];
     }
 }
 const loc = {

package/dist/ui/player/carousel/carousel-localization.js

@@ -1,7 +1,7 @@
-import { getLocale } from '../../../locale';
+import { AppLocale } from '../../../core/locale';
 export class CarouselLocalization {
     get nOfM() {
-        return loc.nOfM[getLocale()];
+        return loc.nOfM[AppLocale.current];
     }
 }
 const loc = {

package/dist/ui/swipe-indicator/swipe-indicator-localization.js

@@ -1,7 +1,7 @@
-import { getLocale } from '../../locale';
+import { AppLocale } from '../../core/locale';
 export class SwipeIndicatorLocalization {
     get swipe() {
-        return loc.swipe[getLocale()];
+        return loc.swipe[AppLocale.current];
     }
 }
 const loc = {

package/dist/ui/time-ago/time-ago-localization.js

@@ -1,28 +1,28 @@
-import { getLocale } from '../../locale';
+import { AppLocale } from '../../core/locale';
 export class TimeAgoLocalization {
     get locale() {
-        return loc.locale[getLocale()];
+        return loc.locale[AppLocale.current];
     }
     get aMinuteAgo() {
-        return loc.aMinuteAgo[getLocale()];
+        return loc.aMinuteAgo[AppLocale.current];
     }
     get anHourAgo() {
-        return loc.anHourAgo[getLocale()];
+        return loc.anHourAgo[AppLocale.current];
     }
     get justNow() {
-        return loc.justNow[getLocale()];
+        return loc.justNow[AppLocale.current];
     }
     get at() {
-        return loc.at[getLocale()];
+        return loc.at[AppLocale.current];
     }
     get hoursAgo() {
-        return loc.hoursAgo[getLocale()];
+        return loc.hoursAgo[AppLocale.current];
     }
     get minutesAgo() {
-        return loc.minutesAgo[getLocale()];
+        return loc.minutesAgo[AppLocale.current];
     }
     get yesterday() {
-        return loc.yesterday[getLocale()];
+        return loc.yesterday[AppLocale.current];
     }
 }
 const loc = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",
@@ -52,6 +52,10 @@
       "types": "./dist/core/i18n/index.d.ts",
       "svelte": "./dist/core/i18n/index.js"
     },
+    "./core/locale": {
+      "types": "./dist/core/locale/index.d.ts",
+      "svelte": "./dist/core/locale/index.js"
+    },
     "./core/media": {
       "types": "./dist/core/media/index.d.ts",
       "svelte": "./dist/core/media/index.js"
@@ -80,10 +84,6 @@
       "types": "./dist/core/validation/index.d.ts",
       "svelte": "./dist/core/validation/index.js"
     },
-    "./locale": {
-      "types": "./dist/locale/index.d.ts",
-      "svelte": "./dist/locale/index.js"
-    },
     "./ui/button": {
       "types": "./dist/ui/button/index.d.ts",
       "svelte": "./dist/ui/button/index.js"

package/dist/locale/index.d.ts

@@ -1 +0,0 @@
-export { getLocale, type Locale, type LocalizationSchema, setLocale } from './locale.svelte';

package/dist/locale/index.js

@@ -1 +0,0 @@
-export { getLocale, setLocale } from './locale.svelte';

package/dist/locale/locale.svelte.d.ts

@@ -1,6 +0,0 @@
-export type Locale = 'en' | 'no';
-export type LocalizationSchema = {
-    [key: string]: Record<Locale, unknown>;
-};
-export declare const getLocale: () => Locale;
-export declare const setLocale: (value: Locale) => void;

package/dist/locale/locale.svelte.js

@@ -1,5 +0,0 @@
-let locale = $state('en');
-export const getLocale = () => locale;
-export const setLocale = (value) => {
-    locale = value;
-};