@streamscloud/kit 0.0.1-1770364570820

package/dist/core/files/files-provider.d.ts

@@ -0,0 +1,8 @@
+import type { FileWithBlobUrl } from './types';
+export declare class FilesProvider {
+    readonly maxCacheSize: number;
+    private cache;
+    constructor(maxCacheSize?: number);
+    getFile(fileSrc: string | null | undefined): Promise<FileWithBlobUrl | undefined>;
+    clearCache(): void;
+}

package/dist/core/files/files-provider.js

@@ -0,0 +1,38 @@
+import { fetchFile } from './file-service';
+import { FileWithBlobDataHelper } from './file-with-blob-data-helper';
+export class FilesProvider {
+    maxCacheSize;
+    cache = new Map();
+    constructor(maxCacheSize = 3) {
+        this.maxCacheSize = maxCacheSize;
+    }
+    async getFile(fileSrc) {
+        if (!fileSrc) {
+            return undefined;
+        }
+        const cached = this.cache.get(fileSrc);
+        if (cached) {
+            return FileWithBlobDataHelper.fromFile(cached.file);
+        }
+        const file = await fetchFile(fileSrc);
+        if (!file) {
+            return undefined;
+        }
+        this.cache.set(fileSrc, { timestamp: Date.now(), file });
+        if (this.cache.size > this.maxCacheSize) {
+            let oldestKey = '';
+            let oldestTime = Infinity;
+            for (const [key, item] of this.cache) {
+                if (item.timestamp < oldestTime) {
+                    oldestTime = item.timestamp;
+                    oldestKey = key;
+                }
+            }
+            this.cache.delete(oldestKey);
+        }
+        return FileWithBlobDataHelper.fromFile(file);
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}

package/dist/core/files/image-resizer.d.ts

@@ -0,0 +1,31 @@
+import type { BlobWithName } from './types';
+export declare const resizeImage: <T extends File>(file: T, limits: {
+    max1: number;
+    max2: number;
+}) => Promise<BlobWithName>;
+/**
+ * Resizes an image while maintaining its aspect ratio, ensuring that both dimensions fit within the given constraints.
+ *
+ * The function takes two numeric constraints (`max1` and `max2`) and determines which one applies to the long side
+ * and which one applies to the short side of the image.
+ *
+ * - If the image already fits within the constraints (both sides are within their respective limits),
+ *   it is returned unchanged.
+ * - If both constraints are provided, the image is resized so that the long side matches its limit.
+ *   However, if this causes the short side to exceed its limit, the short side constraint is applied instead.
+ * - If only one constraint is provided, it is applied to the longer side, and the other side is scaled proportionally.
+ * - If both constraints are zero or negative, the original image is returned without modifications.
+ *
+ * @param blob - The original image as a `Blob` object.
+ * @param limits - An object containing two numeric constraints, `max1` and `max2`.
+ *   - **`max1`** - One of the two size constraints.
+ *   - **`max2`** - The second size constraint.
+ *     **Note:** `max1` and `max2` are not tied to specific dimensions (width or height).
+ *     The function determines which one applies to the long side and which to the short side.
+ *
+ * @returns A promise that resolves to a new resized `Blob` object, or the original `Blob` if resizing is not needed.
+ */
+export declare const resizeBlob: <T extends Blob>(blob: T, limits: {
+    max1: number;
+    max2: number;
+}) => Promise<Blob>;

package/dist/core/files/image-resizer.js

@@ -0,0 +1,92 @@
+let cachedCanvas = null;
+const getCanvas = () => (cachedCanvas ??= document.createElement('canvas'));
+export const resizeImage = async (file, limits) => {
+    const blob = await resizeBlob(file, limits);
+    const result = blob;
+    if (!(blob instanceof File)) {
+        result.name = file.name;
+    }
+    return result;
+};
+/**
+ * Resizes an image while maintaining its aspect ratio, ensuring that both dimensions fit within the given constraints.
+ *
+ * The function takes two numeric constraints (`max1` and `max2`) and determines which one applies to the long side
+ * and which one applies to the short side of the image.
+ *
+ * - If the image already fits within the constraints (both sides are within their respective limits),
+ *   it is returned unchanged.
+ * - If both constraints are provided, the image is resized so that the long side matches its limit.
+ *   However, if this causes the short side to exceed its limit, the short side constraint is applied instead.
+ * - If only one constraint is provided, it is applied to the longer side, and the other side is scaled proportionally.
+ * - If both constraints are zero or negative, the original image is returned without modifications.
+ *
+ * @param blob - The original image as a `Blob` object.
+ * @param limits - An object containing two numeric constraints, `max1` and `max2`.
+ *   - **`max1`** - One of the two size constraints.
+ *   - **`max2`** - The second size constraint.
+ *     **Note:** `max1` and `max2` are not tied to specific dimensions (width or height).
+ *     The function determines which one applies to the long side and which to the short side.
+ *
+ * @returns A promise that resolves to a new resized `Blob` object, or the original `Blob` if resizing is not needed.
+ */
+export const resizeBlob = (blob, limits) => {
+    const { max1, max2 } = limits;
+    if (max1 <= 0 && max2 <= 0) {
+        return Promise.resolve(blob);
+    }
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.src = URL.createObjectURL(blob);
+        image.onload = () => {
+            const { width, height } = image;
+            const isHorizontal = width > height;
+            const originalLongSide = isHorizontal ? width : height;
+            const originalShortSide = isHorizontal ? height : width;
+            const [longSideMax, shortSideMax] = max1 >= max2 ? [max1, max2] : [max2, max1];
+            if (longSideMax > 0 && originalLongSide <= longSideMax && shortSideMax > 0 && originalShortSide <= shortSideMax) {
+                URL.revokeObjectURL(image.src);
+                return resolve(blob);
+            }
+            let newLongSide = Math.min(originalLongSide, longSideMax);
+            let newShortSide = originalShortSide * (newLongSide / originalLongSide);
+            if (shortSideMax > 0 && newShortSide > shortSideMax) {
+                const reducer = newShortSide / shortSideMax;
+                newShortSide = shortSideMax;
+                newLongSide = newLongSide / reducer;
+            }
+            newLongSide = Math.floor(newLongSide);
+            newShortSide = Math.floor(newShortSide);
+            // Skip resize if dimensions unchanged (avoids lossy re-encoding)
+            if (newLongSide === originalLongSide && newShortSide === originalShortSide) {
+                URL.revokeObjectURL(image.src);
+                return resolve(blob);
+            }
+            const newWidth = isHorizontal ? newLongSide : newShortSide;
+            const newHeight = isHorizontal ? newShortSide : newLongSide;
+            const canvas = getCanvas();
+            canvas.width = newWidth;
+            canvas.height = newHeight;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                URL.revokeObjectURL(image.src);
+                return reject(new Error('Failed to get canvas context'));
+            }
+            ctx.drawImage(image, 0, 0, newWidth, newHeight);
+            canvas.toBlob((resizedBlob) => {
+                URL.revokeObjectURL(image.src);
+                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                if (resizedBlob) {
+                    resolve(resizedBlob);
+                }
+                else {
+                    reject(new Error('Failed to create blob from canvas'));
+                }
+            }, blob.type);
+        };
+        image.onerror = () => {
+            URL.revokeObjectURL(image.src);
+            reject(new Error('Failed to load image'));
+        };
+    });
+};

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

@@ -0,0 +1,9 @@
+export type { BlobWithName, FileWithBlobUrl, FileWithUploadUrl } from './types';
+export { toBlobWithName, toFileWithUploadUrl } from './types';
+export { uploadBlob } from './blob-storage';
+export { FileHelper } from './file-helper';
+export { downloadBlob, downloadFromUrl, downloadJson, fetchFile } from './file-service';
+export { AcceptFileType, matchesAcceptedFileTypes } from './file-types';
+export { resizeBlob, resizeImage } from './image-resizer';
+export { FileWithBlobDataHelper } from './file-with-blob-data-helper';
+export { FilesProvider } from './files-provider';

package/dist/core/files/index.js

@@ -0,0 +1,9 @@
+// Utilities
+export { toBlobWithName, toFileWithUploadUrl } from './types';
+export { uploadBlob } from './blob-storage';
+export { FileHelper } from './file-helper';
+export { downloadBlob, downloadFromUrl, downloadJson, fetchFile } from './file-service';
+export { AcceptFileType, matchesAcceptedFileTypes } from './file-types';
+export { resizeBlob, resizeImage } from './image-resizer';
+export { FileWithBlobDataHelper } from './file-with-blob-data-helper';
+export { FilesProvider } from './files-provider';

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

@@ -0,0 +1,12 @@
+export type FileWithBlobUrl = File & {
+    blobUrl: string;
+    id: string;
+};
+export type FileWithUploadUrl<T extends File = File> = T & {
+    uploadUrl: string;
+};
+export declare const toFileWithUploadUrl: <T extends File>(file: T, uploadUrl: string) => FileWithUploadUrl<T>;
+export type BlobWithName = Blob & {
+    name: string;
+};
+export declare const toBlobWithName: (blob: Blob, name: string) => BlobWithName;

package/dist/core/files/types.js

@@ -0,0 +1,10 @@
+export const toFileWithUploadUrl = (file, uploadUrl) => {
+    const fileWithUploadUrl = file;
+    fileWithUploadUrl.uploadUrl = uploadUrl;
+    return fileWithUploadUrl;
+};
+export const toBlobWithName = (blob, name) => {
+    const blobWithName = blob;
+    blobWithName.name = name;
+    return blobWithName;
+};

package/dist/core/graphql.d.ts

@@ -0,0 +1,4 @@
+export declare const createGQLClient: (data: {
+    url: string;
+    customFetch?: typeof fetch;
+}) => import("@urql/core").Client;

package/dist/core/graphql.js

@@ -0,0 +1,10 @@
+import { createClient, fetchExchange } from '@urql/core';
+export const createGQLClient = (data) => createClient({
+    url: data.url,
+    requestPolicy: 'network-only',
+    fetchOptions: {
+        credentials: 'include'
+    },
+    fetch: data.customFetch ?? fetch,
+    exchanges: [fetchExchange]
+});

package/dist/core/handle-generator.d.ts

@@ -0,0 +1 @@
+export declare const generateHandle: (base: string | null | undefined) => string;

package/dist/core/handle-generator.js

@@ -0,0 +1,32 @@
+const SPEC_SYMBOLS = [
+    { symbol: 'å', replacement: 'a' },
+    { symbol: 'Å', replacement: 'A' },
+    { symbol: 'æ', replacement: 'ae' },
+    { symbol: 'Æ', replacement: 'Ae' },
+    { symbol: 'ø', replacement: 'o' },
+    { symbol: 'Ø', replacement: 'O' },
+    { symbol: 'ö', replacement: 'o' },
+    { symbol: 'Ö', replacement: 'O' },
+    { symbol: 'ä', replacement: 'a' },
+    { symbol: 'Ä', replacement: 'A' }
+];
+export const generateHandle = (base) => {
+    if (!base) {
+        return '';
+    }
+    let handle = base;
+    // Replace nordic/special chars
+    for (const { symbol, replacement } of SPEC_SYMBOLS) {
+        handle = handle.replace(new RegExp(symbol, 'g'), replacement);
+    }
+    handle = handle
+        // Insert hyphen before uppercase (camelCase → kebab-case)
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        // Lowercase
+        .toLowerCase()
+        // Replace any non-alphanumeric with hyphen
+        .replace(/[^a-z0-9]+/g, '-')
+        // Remove leading/trailing hyphens
+        .replace(/^-+|-+$/g, '');
+    return handle;
+};

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

@@ -0,0 +1 @@
+export { plural } from './plural';

package/dist/core/i18n/index.js

@@ -0,0 +1 @@
+export { plural } from './plural';

package/dist/core/i18n/plural.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Plural function for wuchale i18n.
+ * Wuchale extracts the candidates array and compiles locale-specific plural rules.
+ *
+ * @param count - The number to pluralize
+ * @param candidates - Array of plural forms, e.g., ['One item', '# items']
+ * @param rule - Optional plural rule function (injected by wuchale at compile time)
+ * @returns The appropriate plural form with # replaced by count
+ *
+ * @example
+ * plural(1, ['# item', '# items']) // "1 item"
+ * plural(5, ['# item', '# items']) // "5 items"
+ */
+export declare const plural: (count: number, candidates: string[], rule?: (n: number) => number) => string;

package/dist/core/i18n/plural.js

@@ -0,0 +1,18 @@
+/**
+ * Plural function for wuchale i18n.
+ * Wuchale extracts the candidates array and compiles locale-specific plural rules.
+ *
+ * @param count - The number to pluralize
+ * @param candidates - Array of plural forms, e.g., ['One item', '# items']
+ * @param rule - Optional plural rule function (injected by wuchale at compile time)
+ * @returns The appropriate plural form with # replaced by count
+ *
+ * @example
+ * plural(1, ['# item', '# items']) // "1 item"
+ * plural(5, ['# item', '# items']) // "5 items"
+ */
+export const plural = (count, candidates, rule = (n) => (n === 1 ? 0 : 1)) => {
+    const index = rule(count);
+    const template = candidates[index] ?? candidates[candidates.length - 1];
+    return template.replace(/#/g, String(count));
+};

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export type { CursorPayload, CursorResult } from './cursor-result';
+export { ContinuationToken } from './continuation-token';
+export { Deferred } from './deferred';
+export { AppEvent, EventDispatcher } from './event-dispatcher';
+export { generateHandle } from './handle-generator';
+export { createGQLClient } from './graphql';

package/dist/core/index.js

@@ -0,0 +1,6 @@
+// Utilities
+export { ContinuationToken } from './continuation-token';
+export { Deferred } from './deferred';
+export { AppEvent, EventDispatcher } from './event-dispatcher';
+export { generateHandle } from './handle-generator';
+export { createGQLClient } from './graphql';

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

@@ -0,0 +1,2 @@
+export type { Repository } from './types';
+export { createRepository } from './repository.svelte';

package/dist/core/repository/index.js

@@ -0,0 +1,2 @@
+// Factory
+export { createRepository } from './repository.svelte';

package/dist/core/repository/map-container.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { WithId } from './types';
+export declare class MapContainer<T extends WithId> {
+    private _container;
+    get items(): T[];
+    add(item: T): void;
+    remove(item: T): void;
+    set(items: T[]): void;
+    clear(): void;
+}

package/dist/core/repository/map-container.svelte.js

@@ -0,0 +1,22 @@
+import { SvelteMap } from 'svelte/reactivity';
+export class MapContainer {
+    _container = new SvelteMap();
+    get items() {
+        return Array.from(this._container.values());
+    }
+    add(item) {
+        this._container.set(item.id, item);
+    }
+    remove(item) {
+        this._container.delete(item.id);
+    }
+    set(items) {
+        this._container.clear();
+        for (const item of items) {
+            this._container.set(item.id, item);
+        }
+    }
+    clear() {
+        this._container.clear();
+    }
+}

package/dist/core/repository/repository-notifier.d.ts

@@ -0,0 +1,19 @@
+import type { WithId } from './types';
+export declare class RepositoryNotifier<T extends WithId> {
+    private _changeSubscribers;
+    private _addSubscribers;
+    private _removeSubscribers;
+    private _clearSubscribers;
+    private _isChangeNotificationPending;
+    private _pendingAddItems;
+    private _pendingRemoveItems;
+    private _isClearNotificationPending;
+    notifyChange(getItems: () => T[]): void;
+    notifyAdd(items: T[]): void;
+    notifyRemove(items: T[]): void;
+    notifyClear(): void;
+    subscribeOnChange(callback: (item: T[]) => void): () => void;
+    subscribeOnAdd(callback: (item: T[]) => void): () => void;
+    subscribeOnRemove(callback: (item: T[]) => void): () => void;
+    subscribeOnClear(callback: () => void): () => void;
+}

package/dist/core/repository/repository-notifier.js

@@ -0,0 +1,88 @@
+// queueMicrotask defers notifications, preventing re-entrant update loops
+export class RepositoryNotifier {
+    _changeSubscribers = new Set();
+    _addSubscribers = new Set();
+    _removeSubscribers = new Set();
+    _clearSubscribers = new Set();
+    _isChangeNotificationPending = false;
+    _pendingAddItems = [];
+    _pendingRemoveItems = [];
+    _isClearNotificationPending = false;
+    notifyChange(getItems) {
+        if (this._changeSubscribers.size === 0) {
+            return;
+        }
+        if (this._isChangeNotificationPending) {
+            return;
+        }
+        this._isChangeNotificationPending = true;
+        queueMicrotask(() => {
+            this._isChangeNotificationPending = false;
+            const currentItems = getItems();
+            this._changeSubscribers.forEach((x) => x(currentItems));
+        });
+    }
+    notifyAdd(items) {
+        if (this._addSubscribers.size === 0) {
+            return;
+        }
+        if (items.length === 0) {
+            return;
+        }
+        const wasEmpty = this._pendingAddItems.length === 0;
+        this._pendingAddItems.push(...items);
+        if (wasEmpty) {
+            queueMicrotask(() => {
+                const itemsToNotify = [...this._pendingAddItems];
+                this._pendingAddItems = [];
+                this._addSubscribers.forEach((x) => x(itemsToNotify));
+            });
+        }
+    }
+    notifyRemove(items) {
+        if (this._removeSubscribers.size === 0) {
+            return;
+        }
+        if (items.length === 0) {
+            return;
+        }
+        const wasEmpty = this._pendingRemoveItems.length === 0;
+        this._pendingRemoveItems.push(...items);
+        if (wasEmpty) {
+            queueMicrotask(() => {
+                const itemsToNotify = [...this._pendingRemoveItems];
+                this._pendingRemoveItems = [];
+                this._removeSubscribers.forEach((x) => x(itemsToNotify));
+            });
+        }
+    }
+    notifyClear() {
+        if (this._clearSubscribers.size === 0) {
+            return;
+        }
+        if (this._isClearNotificationPending) {
+            return;
+        }
+        this._isClearNotificationPending = true;
+        queueMicrotask(() => {
+            this._isClearNotificationPending = false;
+            this._clearSubscribers.forEach((x) => x());
+        });
+    }
+    subscribeOnChange(callback) {
+        this._changeSubscribers.add(callback);
+        return () => this._changeSubscribers.delete(callback);
+    }
+    subscribeOnAdd(callback) {
+        this._addSubscribers.add(callback);
+        return () => this._addSubscribers.delete(callback);
+    }
+    subscribeOnRemove(callback) {
+        this._removeSubscribers.add(callback);
+        return () => this._removeSubscribers.delete(callback);
+    }
+    subscribeOnClear(callback) {
+        this._clearSubscribers.add(callback);
+        return () => this._clearSubscribers.delete(callback);
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { Repository, WithId } from './types';
+export declare const createRepository: <T extends WithId>(limit?: number) => Repository<T>;

package/dist/core/repository/repository.svelte.js

@@ -0,0 +1,59 @@
+import { MapContainer } from './map-container.svelte';
+import { RepositoryNotifier } from './repository-notifier';
+export const createRepository = (limit) => {
+    return new RepositoryInstance(limit);
+};
+class RepositoryInstance {
+    _container = new MapContainer();
+    _limit;
+    _notifier = new RepositoryNotifier();
+    constructor(limit) {
+        this._limit = limit;
+    }
+    get items() {
+        return this._container.items;
+    }
+    get limit() {
+        return this._limit;
+    }
+    add(...items) {
+        const itemsToNotify = [];
+        for (const item of items) {
+            if (!this._limit || this.items.length < this._limit) {
+                this._container.add(item);
+                itemsToNotify.push(item);
+            }
+        }
+        this._notifier.notifyAdd(itemsToNotify);
+        this._notifier.notifyChange(() => this.items);
+    }
+    set(...items) {
+        const itemsToSet = items.slice(0, this.limit);
+        this._container.set(itemsToSet);
+        this._notifier.notifyChange(() => this.items);
+    }
+    remove(...items) {
+        for (const item of items) {
+            this._container.remove(item);
+        }
+        this._notifier.notifyRemove(items);
+        this._notifier.notifyChange(() => this.items);
+    }
+    clear() {
+        this._container.clear();
+        this._notifier.notifyClear();
+        this._notifier.notifyChange(() => this.items);
+    }
+    subscribeOnChange(callback) {
+        return this._notifier.subscribeOnChange(callback);
+    }
+    subscribeOnAdd(callback) {
+        return this._notifier.subscribeOnAdd(callback);
+    }
+    subscribeOnRemove(callback) {
+        return this._notifier.subscribeOnRemove(callback);
+    }
+    subscribeOnClear(callback) {
+        return this._notifier.subscribeOnClear(callback);
+    }
+}

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

@@ -0,0 +1,15 @@
+export type WithId = {
+    id: string;
+};
+export interface Repository<T extends WithId> {
+    items: T[];
+    limit?: number;
+    add(...item: T[]): void;
+    remove(...item: T[]): void;
+    set(...item: T[]): void;
+    clear(): void;
+    subscribeOnChange(callback: (item: T[]) => void): () => void;
+    subscribeOnAdd(callback: (item: T[]) => void): () => void;
+    subscribeOnRemove(callback: (item: T[]) => void): () => void;
+    subscribeOnClear(callback: () => void): () => void;
+}

package/dist/core/repository/types.js

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

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

@@ -0,0 +1,15 @@
+import { type AppThemeValue } from './types';
+declare class AppThemeContainer {
+    private _active;
+    private _mediaQuery;
+    private _isDarkMode;
+    get active(): AppThemeValue;
+    /** Whether dark mode is currently active (resolves 'auto' based on system preference) */
+    get isDarkMode(): boolean;
+    set active(value: AppThemeValue);
+    init: (serverTheme?: AppThemeValue) => void;
+    toggle: () => void;
+    private applyToDocument;
+}
+export declare const AppTheme: AppThemeContainer;
+export {};

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

@@ -0,0 +1,48 @@
+import { isBrowser } from '../utils';
+import { ThemeCookie } from './theme-cookie';
+import { getColorScheme } from './types';
+class AppThemeContainer {
+    _active = $state('auto');
+    _mediaQuery = null;
+    _isDarkMode = $state(false);
+    get active() {
+        return this._active;
+    }
+    /** Whether dark mode is currently active (resolves 'auto' based on system preference) */
+    get isDarkMode() {
+        return this._isDarkMode;
+    }
+    set active(value) {
+        this._active = value;
+        ThemeCookie.set(value);
+        this.applyToDocument();
+    }
+    init = (serverTheme) => {
+        this._active = serverTheme ?? ThemeCookie.get() ?? 'auto';
+        if (isBrowser()) {
+            this._mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+            this._mediaQuery.addEventListener('change', () => {
+                if (this._active === 'auto') {
+                    this.applyToDocument();
+                }
+            });
+        }
+        this.applyToDocument();
+    };
+    toggle = () => {
+        this.active = this.isDarkMode ? 'light' : 'dark';
+    };
+    applyToDocument = () => {
+        if (!isBrowser()) {
+            return;
+        }
+        if (this._active === 'auto') {
+            this._isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches;
+        }
+        else {
+            this._isDarkMode = this._active === 'dark';
+        }
+        document.documentElement.style.colorScheme = getColorScheme(this._active);
+    };
+}
+export const AppTheme = new AppThemeContainer();

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

@@ -0,0 +1,4 @@
+export { AppTheme } from './app-theme.svelte';
+export { ThemeCookie } from './theme-cookie';
+export { APP_THEME_COOKIE, APP_THEME_VALUES, isValidTheme, getColorScheme } from './types';
+export type { AppThemeValue } from './types';

package/dist/core/theme/index.js

@@ -0,0 +1,3 @@
+export { AppTheme } from './app-theme.svelte';
+export { ThemeCookie } from './theme-cookie';
+export { APP_THEME_COOKIE, APP_THEME_VALUES, isValidTheme, getColorScheme } from './types';

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

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