@streamscloud/kit 0.0.1-1770364570820

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

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

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

@@ -0,0 +1,5 @@
+export declare const APP_THEME_COOKIE = "app-theme";
+export declare const APP_THEME_VALUES: readonly ["auto", "light", "dark"];
+export type AppThemeValue = (typeof APP_THEME_VALUES)[number];
+export declare const isValidTheme: (value: string | undefined) => value is AppThemeValue;
+export declare const getColorScheme: (theme: AppThemeValue) => string;

package/dist/core/theme/types.js

@@ -0,0 +1,8 @@
+export const APP_THEME_COOKIE = 'app-theme';
+export const APP_THEME_VALUES = ['auto', 'light', 'dark'];
+export const isValidTheme = (value) => {
+    return APP_THEME_VALUES.some((theme) => theme === value);
+};
+export const getColorScheme = (theme) => {
+    return theme === 'auto' ? 'light dark' : theme;
+};

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

@@ -0,0 +1,3 @@
+import './toastr.scss';
+export { Toastr } from './toastr.svelte';
+export type { ToastrAction, ToastrOptions, ToastrPromiseMessages } from './types';

package/dist/core/toastr/index.js

@@ -0,0 +1,2 @@
+import './toastr.scss';
+export { Toastr } from './toastr.svelte';

package/dist/core/toastr/toaster-host.svelte.d.ts

@@ -0,0 +1,5 @@
+export declare class ToasterHost {
+    private static _ready;
+    private static _mountPromise;
+    static ensure(): Promise<void>;
+}

package/dist/core/toastr/toaster-host.svelte.js

@@ -0,0 +1,40 @@
+import { AppTheme } from '../theme';
+import { mount, tick } from 'svelte';
+import { Toaster } from 'svelte-sonner';
+export class ToasterHost {
+    static _ready = false;
+    static _mountPromise = null;
+    static async ensure() {
+        if (this._ready) {
+            return;
+        }
+        if (this._mountPromise) {
+            return this._mountPromise;
+        }
+        if (typeof document === 'undefined') {
+            return;
+        }
+        this._mountPromise = (async () => {
+            const container = document.createElement('div');
+            container.id = 'toastr-container';
+            document.body.appendChild(container);
+            mount(Toaster, {
+                target: container,
+                props: {
+                    richColors: true,
+                    position: 'bottom-right',
+                    closeButton: true,
+                    visibleToasts: 4,
+                    get theme() {
+                        return AppTheme.isDarkMode ? 'dark' : 'light';
+                    },
+                    style: 'font-family: inherit;',
+                    toastOptions: { class: 'sc-toast' }
+                }
+            });
+            await tick();
+            this._ready = true;
+        })();
+        return this._mountPromise;
+    }
+}

package/dist/core/toastr/toastr.scss

@@ -0,0 +1,27 @@
+.sc-toast[data-sonner-toast] {
+  font-family: inherit;
+  --toast-close-button-start: auto;
+  --toast-close-button-end: 0;
+  --toast-close-button-transform: translate(35%, -35%);
+
+  // Action button - type-specific styles (inverted colors for contrast)
+  &[data-type='success'] [data-button] {
+    background: var(--success-text);
+    color: var(--success-bg);
+  }
+
+  &[data-type='error'] [data-button] {
+    background: var(--error-text);
+    color: var(--error-bg);
+  }
+
+  &[data-type='warning'] [data-button] {
+    background: var(--warning-text);
+    color: var(--warning-bg);
+  }
+
+  &[data-type='info'] [data-button] {
+    background: var(--info-text);
+    color: var(--info-bg);
+  }
+}

package/dist/core/toastr/toastr.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ToastrOptions, ToastrPromiseMessages } from './types';
+export declare class Toastr {
+    static error(message: string, options?: ToastrOptions): Promise<void>;
+    static success(message: string, options?: ToastrOptions): Promise<void>;
+    static warning(message: string, options?: ToastrOptions): Promise<void>;
+    static info(message: string, options?: ToastrOptions): Promise<void>;
+    static promise<T>(promise: Promise<T> | (() => Promise<T>), messages: ToastrPromiseMessages<T>): Promise<void>;
+}

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

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

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

@@ -0,0 +1,14 @@
+export interface ToastrAction {
+    label: string;
+    onClick: () => void;
+}
+export interface ToastrOptions {
+    action?: ToastrAction;
+    description?: string;
+    duration?: number;
+}
+export interface ToastrPromiseMessages<T> {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((error: unknown) => string);
+}

package/dist/core/toastr/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export { slideHorizontally } from './slide-horizontally';

package/dist/core/transitions/index.js

@@ -0,0 +1 @@
+export { slideHorizontally } from './slide-horizontally';

package/dist/core/transitions/slide-horizontally.d.ts

@@ -0,0 +1,8 @@
+import type { TransitionConfig } from 'svelte/transition';
+interface SlideHorizontallyOptions {
+    delay?: number;
+    duration?: number;
+    easing?: (t: number) => number;
+}
+export declare const slideHorizontally: (node: HTMLElement, { delay, duration, easing }?: SlideHorizontallyOptions) => TransitionConfig;
+export {};

package/dist/core/transitions/slide-horizontally.js

@@ -0,0 +1,54 @@
+import { sineInOut } from 'svelte/easing';
+export const slideHorizontally = (node, { delay = 0, duration = 400, easing = sineInOut } = {}) => {
+    const style = getComputedStyle(node);
+    const isHtmlElement = (n) => n.nodeType === Node.ELEMENT_NODE;
+    const children = Array.from(node.children).filter(isHtmlElement);
+    children.forEach((child) => {
+        const childStyle = getComputedStyle(child);
+        child.style.width = childStyle.width;
+        child.style.minWidth = childStyle.width;
+        child.style.maxWidth = childStyle.maxWidth;
+    });
+    const opacity = +style.opacity;
+    const width = parseFloat(style.width);
+    const paddingLeft = parseFloat(style.paddingLeft);
+    const paddingRight = parseFloat(style.paddingRight);
+    const marginLeft = parseFloat(style.marginLeft);
+    const marginRight = parseFloat(style.marginRight);
+    const borderLeftWidth = parseFloat(style.borderLeftWidth);
+    const borderRightWidth = parseFloat(style.borderRightWidth);
+    let initialT = undefined;
+    let initialU = undefined;
+    return {
+        delay,
+        duration,
+        easing,
+        css: (t, u) => {
+            if (initialT === undefined) {
+                initialT = t;
+            }
+            if (initialU === undefined) {
+                initialU = u;
+            }
+            return ('overflow: hidden;' +
+                `opacity: ${Math.min(t, 1) * opacity};` +
+                `width: ${t * width}px;` +
+                `min-width: ${t * width}px;` +
+                `padding-left: ${t * paddingLeft}px;` +
+                `padding-right: ${t * paddingRight}px;` +
+                `margin-left: ${t * marginLeft}px;` +
+                `margin-right: ${t * marginRight}px;` +
+                `border-left-width: ${t * borderLeftWidth}px;` +
+                `border-right-width: ${t * borderRightWidth}px;`);
+        },
+        tick: (t, u) => {
+            if ((initialT === 0 && t === 1) || (initialU === 0 && u === 1)) {
+                children.forEach((child) => {
+                    child.style.width = '';
+                    child.style.minWidth = '';
+                    child.style.maxWidth = '';
+                });
+            }
+        }
+    };
+};

package/dist/core/utils/array-helper.d.ts

@@ -0,0 +1,21 @@
+export declare class ArrayHelper {
+    static distinct<T>(items: T[]): T[];
+    static distinctBy<T>(items: T[], keyFn: (elem: T) => unknown): T[];
+    static intersect<T>(arrays: T[][]): T[];
+    static assertHasValue<T>(value: T | null | undefined): value is T;
+    /**
+     * Find position ("from" and "to" indexes) of the element that was moved inside array (only one element should be moved)
+     */
+    static findMovedElement(initial: unknown[], modified: unknown[]): {
+        from: number;
+        to: number;
+    } | undefined;
+    static moveArrayItem<T>(arr: ReadonlyArray<T>, from: number, to: number): T[];
+    static replaceArrayItem<T>(arr: T[], originalItem: T, newItem: T): T[];
+    static sortArray<T>(array: Array<T> | ReadonlyArray<T>, propertyFunc: (elem: T) => unknown): T[];
+    static sortArrayDescending<T>(array: T[], propertyFunc: (elem: T) => unknown): T[];
+    static groupBy<T>(array: T[], keyResolver: (elem: T) => string): Record<string, T[]>;
+    static repeat<T>(itemFn: (i: number) => T, length: number): T[];
+    static areEqual<T>(array1?: T[] | null, array2?: T[] | null): boolean;
+    private static sortArrayInternal;
+}

package/dist/core/utils/array-helper.js

@@ -0,0 +1,130 @@
+export class ArrayHelper {
+    static distinct(items) {
+        return Array.from(new Set(items));
+    }
+    static distinctBy(items, keyFn) {
+        return Array.from(new Map(items.map((item) => [keyFn(item), item])).values());
+    }
+    static intersect(arrays) {
+        if (!arrays?.length) {
+            return [];
+        }
+        return arrays.reduce((result, current) => result.filter((item) => current.includes(item)));
+    }
+    static assertHasValue(value) {
+        return value !== null && value !== undefined;
+    }
+    /**
+     * Find position ("from" and "to" indexes) of the element that was moved inside array (only one element should be moved)
+     */
+    static findMovedElement(initial, modified) {
+        if (initial.length !== modified.length) {
+            throw new Error('Arrays should have the same number of elements.');
+        }
+        if (initial.length !== new Set(initial).size || modified.length !== new Set(modified).size) {
+            throw new Error("Arrays shouldn't have duplicates.");
+        }
+        const res = { from: -1, to: -1 };
+        let i = 0;
+        for (i; i < initial.length; i++) {
+            if (initial[i] !== modified[i]) {
+                if (initial[i] === modified[i + 1]) {
+                    res.to = i;
+                }
+                else {
+                    res.from = i;
+                }
+                break;
+            }
+        }
+        if (i === initial.length) {
+            return;
+        }
+        let j = initial.length;
+        for (j; j > i; j--) {
+            if (initial[j] !== modified[j]) {
+                if (res.from === -1) {
+                    res.from = j;
+                }
+                else {
+                    res.to = j;
+                }
+                break;
+            }
+        }
+        return res;
+    }
+    static moveArrayItem(arr, from, to) {
+        if (!arr?.length || from < 0 || from >= arr.length || to < 0 || to >= arr.length || from === to) {
+            return [...arr];
+        }
+        const cloned = [...arr];
+        cloned.splice(to, 0, cloned.splice(from, 1)[0]);
+        return cloned;
+    }
+    static replaceArrayItem(arr, originalItem, newItem) {
+        const index = arr.indexOf(originalItem);
+        if (index < 0) {
+            return arr;
+        }
+        const cloned = [...arr];
+        cloned.splice(index, 1, newItem);
+        return cloned;
+    }
+    static sortArray(array, propertyFunc) {
+        return ArrayHelper.sortArrayInternal(array, true, propertyFunc);
+    }
+    static sortArrayDescending(array, propertyFunc) {
+        return ArrayHelper.sortArrayInternal(array, false, propertyFunc);
+    }
+    static groupBy(array, keyResolver) {
+        return array.reduce((resultValue, value) => {
+            const groupKey = keyResolver(value);
+            (resultValue[groupKey] = resultValue[groupKey] || []).push(value);
+            return resultValue;
+        }, {});
+    }
+    static repeat(itemFn, length) {
+        return [...Array(length)].map((_, i) => itemFn(i));
+    }
+    static areEqual(array1, array2) {
+        if (array1 === array2) {
+            return true;
+        }
+        if (!array1 && !array2) {
+            return true;
+        }
+        if (!array1 || !array2) {
+            return false;
+        }
+        return array1.length === array2.length && array1.every((element, index) => element === array2[index]);
+    }
+    static sortArrayInternal(array, ascending, propertyFunc) {
+        const clone = [...array];
+        return clone.sort((val1, val2) => {
+            const a = propertyFunc(val1);
+            const b = propertyFunc(val2);
+            const left = ascending ? a : b;
+            const right = ascending ? b : a;
+            if (!left && !right) {
+                return 0;
+            }
+            if (!left) {
+                return -1;
+            }
+            if (!right) {
+                return 1;
+            }
+            if (typeof left === 'string' && typeof right === 'string') {
+                return left.localeCompare(right);
+            }
+            if (left < right) {
+                return -1;
+            }
+            if (left > right) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+}

package/dist/core/utils/base64-serializer.d.ts

@@ -0,0 +1,4 @@
+export declare class Base64Serializer {
+    static encodeString: (str: string) => string;
+    static decodeToString: (b64: string) => string;
+}

package/dist/core/utils/base64-serializer.js

@@ -0,0 +1,21 @@
+export class Base64Serializer {
+    // Encode a Unicode string to base64 (browser safe)
+    static encodeString = (str) => {
+        // Convert string to UTF-8 bytes
+        const utf8Bytes = new TextEncoder().encode(str);
+        // Convert bytes to binary string
+        let binary = '';
+        utf8Bytes.forEach((b) => (binary += String.fromCharCode(b)));
+        // Encode binary string to base64
+        return btoa(binary);
+    };
+    // Decode a base64 string back to Unicode (browser safe)
+    static decodeToString = (b64) => {
+        // Decode base64 to binary string
+        const binary = atob(b64);
+        // Convert binary string to UTF-8 bytes
+        const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+        // Decode UTF-8 bytes back to string
+        return new TextDecoder().decode(bytes);
+    };
+}

package/dist/core/utils/browser.d.ts

@@ -0,0 +1 @@
+export declare const isBrowser: () => boolean;

package/dist/core/utils/browser.js

@@ -0,0 +1 @@
+export const isBrowser = () => typeof window !== 'undefined';

package/dist/core/utils/date-helper.d.ts

@@ -0,0 +1,51 @@
+export declare class DateHelper {
+    static toDate(date: LikeDate, resetTime?: boolean): Date;
+    static addMonths(date: LikeDate, months?: number): Date;
+    static addDays(date: LikeDate, days: number): Date;
+    static secondsToTimeRepresentation(seconds: number, duration: number): string;
+    static getDate(date: LikeDate): number;
+    static getYear(date: LikeDate): number;
+    static getDiffInDays(date1: LikeDate, date2: LikeDate): number;
+    static getMonthName(date: LikeDate, locale: string, short?: boolean): string;
+    static getWeekdayName(date: LikeDate, locale: string, short?: boolean): string;
+    static getMonthRange(date: LikeDate): MonthRange;
+    static daysInMonth(date: LikeDate): number;
+    static getDayOfWeek(date: LikeDate): number;
+    static getShiftedDate(date: LikeDate, daysShift: number): Date;
+    static getDateOnlyString(date: LikeDate): string;
+    static formatDateRange(startDate: LikeDate, endDate: LikeDate, locale: string): string;
+    static dateRangeDescriptionString(startDate: LikeDate, endDate: LikeDate | null | undefined, locale: string): string;
+    static toDefaultDateTimeRepresentation: (val: LikeDate, locale: string, alwaysIncludeYear?: boolean) => string;
+    static addYears(dateToModify: LikeDate, yearsToAdd: number, resetTime?: boolean): Date;
+    static startOfLastWeek(): string;
+    static endOfLastWeek(): string;
+    static startOfLastMonth(): string;
+    static endOfLastMonth(): string;
+    static startOfLastYear(): string;
+    static endOfLastYear(): string;
+    static startOfRollingDays(days: number): string;
+    static endOfRollingDays(): string;
+    static startOfCurrentMonthToNow(): {
+        from: string;
+        to: string;
+    };
+    static startOfCurrentYearToNow(): {
+        from: string;
+        to: string;
+    };
+}
+export declare class DateFormatOptions {
+    static dateTimeFormat: Intl.DateTimeFormatOptions;
+    static dateTimeWithoutYearFormat: Intl.DateTimeFormatOptions;
+    static timeFormat: Intl.DateTimeFormatOptions;
+    static dateFormat: Intl.DateTimeFormatOptions;
+    static dateNumericFormat: Intl.DateTimeFormatOptions;
+    static dateFormatWithoutYear: Intl.DateTimeFormatOptions;
+    static dateFullMonthFormat: Intl.DateTimeFormatOptions;
+}
+export type MonthRange = {
+    firstDay: Date;
+    lastDay: Date;
+};
+type LikeDate = string | number | Date;
+export {};