@korioinc/next-core 1.0.0

package/dist/i18n/routing.d.ts

@@ -0,0 +1,25 @@
+import type { ReadonlyURLSearchParams } from 'next/navigation';
+import { type NextRequest, NextResponse } from 'next/server';
+/**
+ * Get all available locales
+ */
+export declare function getLocales(): string[];
+/**
+ * Get default locale
+ */
+export declare function getDefaultLocale(): string;
+export declare function handleLocaleRouting(request: NextRequest): NextResponse<unknown>;
+export declare function getRequestLocale(requestHeaders: Headers): string;
+export declare function getCookieLocale(requestHeaders: Headers, pathname?: string): string | undefined;
+export declare function getChangeLocalePath(pathname: string, currentLocale: string, nextLocale: string): string;
+export declare function getPathname({ locale, href }: {
+    locale: string;
+    href: string;
+}): string;
+export declare function getLanguageAlternates(pathname?: string): Record<string, string>;
+export declare function getCurrentPathname(): Promise<string>;
+/**
+ * pathname과 params를 조합하여 전체 URL을 생성하는 함수
+ */
+export declare function getFullUrl(pathname: string, params?: Record<string, string | string[] | undefined> | ReadonlyURLSearchParams | undefined): string;
+//# sourceMappingURL=routing.d.ts.map

package/dist/i18n/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/i18n/routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAgB7D;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,EAAE,CAErC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AA2DD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,yBA2EvD;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM,CAShE;AAED,wBAAgB,eAAe,CAAC,cAAc,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAkB9F;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAoBvG;AAED,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,UAY7E;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,GAAE,MAAY,0BAmC3D;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAK1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,GAAG,uBAAuB,GAAG,SAAS,GAC3F,MAAM,CAkCR"}

package/dist/i18n/routing.js

@@ -0,0 +1,252 @@
+import { NextResponse } from 'next/server';
+import { getCookieFromHeaders } from '../utils/cookie';
+import { match } from '@formatjs/intl-localematcher';
+import linguiConfig from 'lingui.config';
+import Negotiator from 'negotiator';
+const { locales, fallbackLocales } = linguiConfig;
+const DEFAULT_FALLBACK = () => fallbackLocales && typeof fallbackLocales === 'object' ? fallbackLocales.default || 'en' : 'en';
+const LOCALE_COOKIE_NAME = 'NEXT_LOCALE';
+const LOCALE_PREFIX = 'as-needed';
+/**
+ * Get all available locales
+ */
+export function getLocales() {
+    return locales;
+}
+/**
+ * Get default locale
+ */
+export function getDefaultLocale() {
+    return DEFAULT_FALLBACK();
+}
+/**
+ * 쿠키를 설정하는 헬퍼 함수
+ */
+const setCookie = (response, locale) => {
+    response.cookies.set(LOCALE_COOKIE_NAME, locale, {
+        path: '/',
+        sameSite: 'lax',
+    });
+    return response;
+};
+/**
+ * URL에서 locale 부분을 제거하는 헬퍼 함수
+ */
+const removeLocaleFromPath = (pathname, locale) => {
+    return pathname.replace(`/${locale}`, '') || '/';
+};
+/**
+ * URL에서 locale을 제거하고 리다이렉트하는 함수
+ */
+const redirectWithoutLocale = (request, pathname, locale, shouldSetCookie = false) => {
+    const newPathname = removeLocaleFromPath(pathname, locale);
+    const url = new URL(newPathname, request.url);
+    url.search = request.nextUrl.search;
+    url.hash = request.nextUrl.hash;
+    const response = NextResponse.redirect(url, 302);
+    response.headers.set('x-pathname', newPathname);
+    if (shouldSetCookie) {
+        setCookie(response, locale);
+    }
+    return response;
+};
+/**
+ * 내부적으로 locale을 처리하는 rewrite 함수
+ */
+const rewriteWithLocale = (request, pathname, locale) => {
+    const internalUrl = new URL(`/${locale}${pathname}`, request.url);
+    internalUrl.search = request.nextUrl.search;
+    internalUrl.hash = request.nextUrl.hash;
+    const response = NextResponse.rewrite(internalUrl);
+    response.headers.set('x-pathname', pathname);
+    return response;
+};
+export function handleLocaleRouting(request) {
+    const { pathname } = request.nextUrl;
+    const cookies = request.cookies;
+    const localeCookie = cookies.get(LOCALE_COOKIE_NAME);
+    const defaultFallback = DEFAULT_FALLBACK();
+    // 1. URL에서 locale 감지
+    let pathLocale;
+    const pathnameHasLocale = locales.some((locale) => {
+        if (pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`) {
+            pathLocale = locale;
+            return true;
+        }
+        return false;
+    });
+    // 2. URL에 locale이 포함된 경우
+    if (pathnameHasLocale) {
+        // 이미 path에 locale이 있을 때
+        const response = NextResponse.next();
+        response.headers.set('x-pathname', pathname);
+        // 쿠키 값이 path locale과 다를 경우
+        if (localeCookie?.value !== pathLocale) {
+            // 기본 locale인 경우 URL에서 제거
+            if (LOCALE_PREFIX === 'as-needed' && pathLocale === defaultFallback) {
+                return redirectWithoutLocale(request, pathname, pathLocale, true);
+            }
+            // 다른 locale의 경우 쿠키 설정
+            return setCookie(response, pathLocale);
+        }
+        // locale은 같지만 기본 locale이고 as-needed 설정인 경우
+        if (LOCALE_PREFIX === 'as-needed' && pathLocale === defaultFallback) {
+            return redirectWithoutLocale(request, pathname, pathLocale);
+        }
+        return response;
+    }
+    // 3. URL에 locale이 없는 경우
+    // 쿠키가 기본 locale이고, as-needed 설정일 때 내부적으로만 locale 처리
+    if (LOCALE_PREFIX === 'as-needed' && localeCookie?.value === defaultFallback) {
+        return rewriteWithLocale(request, pathname, defaultFallback);
+    }
+    // 4. 적절한 locale 감지 및 적용
+    const defaultLocale = getRequestLocale(request.headers);
+    let locale = getCookieLocale(request.headers, pathname) || defaultLocale;
+    const findLocale = match([locale], locales, defaultLocale);
+    if (locale !== findLocale) {
+        locale = findLocale;
+    }
+    // 기본 locale이고 as-needed 설정인 경우 URL에는 포함하지 않음
+    if (LOCALE_PREFIX === 'as-needed' && locale === defaultFallback) {
+        return rewriteWithLocale(request, pathname, locale);
+    }
+    // 다른 locale은 URL에 표시
+    const newPathname = getChangeLocalePath(pathname, defaultFallback, locale);
+    request.nextUrl.pathname = newPathname;
+    const response = NextResponse.redirect(request.nextUrl);
+    response.headers.set('x-pathname', newPathname);
+    // 쿠키가 없는 경우 설정
+    if (localeCookie?.value === undefined) {
+        setCookie(response, locale);
+    }
+    return response;
+}
+export function getRequestLocale(requestHeaders) {
+    const langHeader = requestHeaders.get('accept-language') || undefined;
+    const languages = new Negotiator({
+        headers: { 'accept-language': langHeader },
+    }).languages(locales.slice());
+    const activeLocale = languages[0] || DEFAULT_FALLBACK();
+    return activeLocale;
+}
+export function getCookieLocale(requestHeaders, pathname) {
+    const cookieLocale = getCookieFromHeaders(requestHeaders, LOCALE_COOKIE_NAME);
+    if (cookieLocale) {
+        return cookieLocale;
+    }
+    let pathLocale = undefined;
+    if (pathname) {
+        const pathMatch = pathname.match(/^\/([^\\/]+)(?:\/|$)/);
+        if (pathMatch && pathMatch[1]) {
+            const potentialLocale = pathMatch[1];
+            if (Array.isArray(locales) && locales.includes(potentialLocale)) {
+                pathLocale = potentialLocale;
+            }
+        }
+    }
+    return pathLocale;
+}
+export function getChangeLocalePath(pathname, currentLocale, nextLocale) {
+    // Create the new path based on whether the current path has a locale segment or not
+    let pathNameWithoutLocale;
+    // Check if pathname starts with current locale
+    if (pathname === `/${currentLocale}` || pathname.startsWith(`/${currentLocale}/`)) {
+        // Path has locale: /ko or /ko/something
+        pathNameWithoutLocale = pathname.slice(currentLocale.length + 1); // Remove /locale part
+        if (pathNameWithoutLocale.startsWith('/')) {
+            pathNameWithoutLocale = pathNameWithoutLocale.slice(1); // Remove leading slash if any
+        }
+    }
+    else if (pathname === '/') {
+        // Root path
+        pathNameWithoutLocale = '';
+    }
+    else {
+        // Path doesn't have locale prefix: /something
+        pathNameWithoutLocale = pathname.startsWith('/') ? pathname.slice(1) : pathname;
+    }
+    return `/${nextLocale}${pathNameWithoutLocale ? '/' + pathNameWithoutLocale : ''}`;
+}
+export function getPathname({ locale, href }) {
+    const defaultFallback = DEFAULT_FALLBACK();
+    if (href === '/' || href === '') {
+        return LOCALE_PREFIX === 'as-needed' && locale === defaultFallback ? '/' : `/${locale}`;
+    }
+    if (LOCALE_PREFIX === 'as-needed' && locale === defaultFallback) {
+        return href.startsWith('/') ? href : `/${href}`;
+    }
+    return href.startsWith('/') ? `/${locale}${href}` : `/${locale}/${href}`;
+}
+export function getLanguageAlternates(pathname = '/') {
+    const defaultFallback = DEFAULT_FALLBACK();
+    // Remove any existing locale from the pathname to get the base path
+    let basePath = pathname;
+    locales.forEach((locale) => {
+        const localePattern = new RegExp(`^/${locale}(/|$)`);
+        if (localePattern.test(basePath)) {
+            basePath = basePath.replace(localePattern, '/');
+        }
+    });
+    // Normalize path
+    basePath = basePath.replace(/\/+/g, '/');
+    const alternates = {};
+    // Set x-default based on LOCALE_PREFIX and defaultFallback
+    if (LOCALE_PREFIX === 'as-needed') {
+        alternates['x-default'] = basePath;
+    }
+    else {
+        alternates['x-default'] = `/${defaultFallback}${basePath === '/' ? '' : basePath}`;
+    }
+    locales
+        .filter((locale) => locale !== 'pseudo')
+        .forEach((locale) => {
+        if (LOCALE_PREFIX === 'as-needed' && locale === defaultFallback) {
+            alternates[locale] = basePath;
+        }
+        else {
+            alternates[locale] = `/${locale}${basePath === '/' ? '' : basePath}`;
+        }
+    });
+    return alternates;
+}
+export async function getCurrentPathname() {
+    const { headers } = await import('next/headers');
+    const headersList = await headers();
+    return headersList.get('x-pathname') || '';
+}
+/**
+ * pathname과 params를 조합하여 전체 URL을 생성하는 함수
+ */
+export function getFullUrl(pathname, params) {
+    const baseUrl = process.env.NEXT_PUBLIC_APP_URL || '';
+    if (!params) {
+        return `${baseUrl}${pathname}`;
+    }
+    const searchParams = new URLSearchParams();
+    // ReadonlyURLSearchParams인 경우
+    if (params instanceof URLSearchParams) {
+        params.forEach((value, key) => {
+            // locale 파라미터는 제외
+            if (key !== 'locale') {
+                searchParams.append(key, value);
+            }
+        });
+    }
+    else {
+        // Record<string, string | string[] | undefined>인 경우
+        Object.entries(params).forEach(([key, value]) => {
+            // undefined 값은 건너뛰기
+            if (value === undefined)
+                return;
+            if (Array.isArray(value)) {
+                value.forEach((v) => searchParams.append(key, v));
+            }
+            else {
+                searchParams.append(key, value);
+            }
+        });
+    }
+    const queryString = searchParams.toString();
+    return `${baseUrl}${pathname}${queryString ? `?${queryString}` : ''}`;
+}

package/dist/local-storage/index.d.ts

@@ -0,0 +1,4 @@
+export { LocalStorageManager, createStorageInstance, storage } from './local-storage-manager';
+export { persist, createPersistedStore } from './valtio-persist';
+export type { PersistOptions } from './valtio-persist';
+//# sourceMappingURL=index.d.ts.map

package/dist/local-storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/local-storage/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAG9F,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGjE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/local-storage/index.js

@@ -0,0 +1,4 @@
+// Local storage manager
+export { LocalStorageManager, createStorageInstance, storage } from './local-storage-manager';
+// Valtio persistence utilities
+export { persist, createPersistedStore } from './valtio-persist';

package/dist/local-storage/local-storage-manager.d.ts

@@ -0,0 +1,41 @@
+interface LocalForageOptions {
+    driver?: string | string[];
+    name?: string;
+    storeName?: string;
+    description?: string;
+}
+interface LocalForageInstance {
+    setItem<T>(key: string, value: T): Promise<T>;
+    getItem<T>(key: string): Promise<T | null>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    createInstance(options: LocalForageOptions): LocalForageInstance;
+}
+export declare const createStorageInstance: (storeName: string) => Promise<LocalForageInstance | null>;
+export declare class LocalStorageManager<T = unknown> {
+    private storageKey;
+    private instanceName?;
+    private instance;
+    private initialized;
+    constructor(key: string, instanceName?: string);
+    private ensureInitialized;
+    setItem(value: T): Promise<T>;
+    getItem(): Promise<T | null>;
+    removeItem(): Promise<void>;
+    hasItem(): Promise<boolean>;
+    updateItem(updateFn: (current: T | null) => T): Promise<T>;
+}
+export declare const storage: {
+    setMultiple(items: Record<string, unknown>): Promise<void>;
+    getMultiple(keys: string[]): Promise<Record<string, unknown>>;
+    removeMultiple(keys: string[]): Promise<void>;
+    clearAll(): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    getStorageInfo(): Promise<{
+        keys: string[];
+        size: number;
+    }>;
+};
+export {};
+//# sourceMappingURL=local-storage-manager.d.ts.map

package/dist/local-storage/local-storage-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-manager.d.ts","sourceRoot":"","sources":["../../src/local-storage/local-storage-manager.ts"],"names":[],"mappings":"AAIA,UAAU,kBAAkB;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,mBAAmB;IAC3B,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9C,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1B,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,mBAAmB,CAAC;CAClE;AAoCD,eAAO,MAAM,qBAAqB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAUjG,CAAC;AAGF,qBAAa,mBAAmB,CAAC,CAAC,GAAG,OAAO;IAC1C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,WAAW,CAAS;gBAEhB,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM;YAKhC,iBAAiB;IA2BzB,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAU7B,OAAO,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAe5B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAiB3B,UAAU,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAMjE;AAGD,eAAO,MAAM,OAAO;uBAEO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;sBAWxC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;yBAwBxC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;gBAWjC,OAAO,CAAC,IAAI,CAAC;kBAUX,OAAO,CAAC,MAAM,EAAE,CAAC;sBAUb,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAmBlE,CAAC"}

package/dist/local-storage/local-storage-manager.js

@@ -0,0 +1,200 @@
+import { isBrowser } from '../utils/helpers';
+import { getConfig } from '@korioinc/next-conf';
+// Lazy-loaded localforage instance
+let localforageInstance = null;
+// Get localforage instance (dynamic import)
+async function getLocalforage() {
+    if (!isBrowser()) {
+        return null;
+    }
+    if (!localforageInstance) {
+        try {
+            const localforageModule = await import('localforage');
+            const localforage = localforageModule.default;
+            const config = await getConfig();
+            // Configure localforage with config values
+            localforage.config({
+                driver: config.storage?.driver || localforage.LOCALSTORAGE, // LOCALSTORAGE, WEBSQL, INDEXEDDB
+                name: config.storage?.name || 'app-storage',
+                storeName: config.storage?.storeName || 'default-store',
+            });
+            localforageInstance = localforage;
+        }
+        catch (error) {
+            console.error('Failed to load localforage:', error);
+            return null;
+        }
+    }
+    return localforageInstance;
+}
+// Create a custom instance for specific data types
+export const createStorageInstance = async (storeName) => {
+    const localforage = await getLocalforage();
+    if (!localforage)
+        return null;
+    const config = await getConfig();
+    return localforage.createInstance({
+        name: config.storage?.name || 'app-storage',
+        storeName: storeName,
+    });
+};
+// Type-safe storage manager
+export class LocalStorageManager {
+    storageKey;
+    instanceName;
+    instance = null;
+    initialized = false;
+    constructor(key, instanceName) {
+        this.storageKey = key;
+        this.instanceName = instanceName;
+    }
+    async ensureInitialized() {
+        if (this.initialized && this.instance) {
+            return true;
+        }
+        if (!isBrowser()) {
+            return false;
+        }
+        try {
+            if (this.instanceName) {
+                this.instance = await createStorageInstance(this.instanceName);
+            }
+            else {
+                this.instance = await getLocalforage();
+            }
+            this.initialized = true;
+            return this.instance !== null;
+        }
+        catch (error) {
+            console.error('Failed to initialize storage:', error);
+            return false;
+        }
+    }
+    // Save item to storage
+    async setItem(value) {
+        const ready = await this.ensureInitialized();
+        if (!ready || !this.instance) {
+            throw new Error('Storage not available');
+        }
+        return await this.instance.setItem(this.storageKey, value);
+    }
+    // Get item from storage
+    async getItem() {
+        const ready = await this.ensureInitialized();
+        if (!ready || !this.instance) {
+            return null;
+        }
+        try {
+            return await this.instance.getItem(this.storageKey);
+        }
+        catch (error) {
+            // Error getting item
+            return null;
+        }
+    }
+    // Remove item from storage
+    async removeItem() {
+        const ready = await this.ensureInitialized();
+        if (!ready || !this.instance) {
+            return;
+        }
+        await this.instance.removeItem(this.storageKey);
+    }
+    // Check if item exists
+    async hasItem() {
+        const ready = await this.ensureInitialized();
+        if (!ready || !this.instance) {
+            return false;
+        }
+        try {
+            const value = await this.instance.getItem(this.storageKey);
+            return value !== null;
+        }
+        catch (error) {
+            // Error checking item
+            return false;
+        }
+    }
+    // Update item (merge with existing data)
+    async updateItem(updateFn) {
+        const current = await this.getItem();
+        const updated = updateFn(current);
+        return await this.setItem(updated);
+    }
+}
+// Utility functions for common operations
+export const storage = {
+    // Set multiple items at once
+    async setMultiple(items) {
+        if (!isBrowser())
+            return;
+        const localforage = await getLocalforage();
+        if (!localforage)
+            return;
+        const promises = Object.entries(items).map(([key, value]) => localforage.setItem(key, value));
+        await Promise.all(promises);
+    },
+    // Get multiple items at once
+    async getMultiple(keys) {
+        if (!isBrowser())
+            return {};
+        const localforage = await getLocalforage();
+        if (!localforage)
+            return {};
+        const promises = keys.map(async (key) => {
+            const value = await localforage.getItem(key);
+            return { key, value };
+        });
+        const results = await Promise.all(promises);
+        return results.reduce((acc, { key, value }) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+    },
+    // Remove multiple items at once
+    async removeMultiple(keys) {
+        if (!isBrowser())
+            return;
+        const localforage = await getLocalforage();
+        if (!localforage)
+            return;
+        const promises = keys.map((key) => localforage.removeItem(key));
+        await Promise.all(promises);
+    },
+    // Clear all storage
+    async clearAll() {
+        if (!isBrowser())
+            return;
+        const localforage = await getLocalforage();
+        if (!localforage)
+            return;
+        await localforage.clear();
+    },
+    // Get all keys
+    async getAllKeys() {
+        if (!isBrowser())
+            return [];
+        const localforage = await getLocalforage();
+        if (!localforage)
+            return [];
+        return await localforage.keys();
+    },
+    // Get storage size info
+    async getStorageInfo() {
+        if (!isBrowser())
+            return { keys: [], size: 0 };
+        const localforage = await getLocalforage();
+        if (!localforage)
+            return { keys: [], size: 0 };
+        const keys = await localforage.keys();
+        let totalSize = 0;
+        for (const key of keys) {
+            const value = await localforage.getItem(key);
+            if (value) {
+                // Rough estimation of size
+                totalSize += JSON.stringify(value).length;
+            }
+        }
+        return { keys, size: totalSize };
+    },
+};

package/dist/local-storage/valtio-persist.d.ts

@@ -0,0 +1,31 @@
+export interface PersistOptions<T> {
+    key: string;
+    storage?: Storage;
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+}
+/**
+ * Valtio persistence helper for Next.js with SSR support
+ * Automatically syncs Valtio state with localStorage/sessionStorage
+ */
+export declare function persist<T extends object>(store: T, options: PersistOptions<T>): {
+    hydrate: () => Promise<void>;
+    clearStorage: () => Promise<void>;
+};
+/**
+ * Create a persisted Valtio store with TypeScript support
+ * Example usage:
+ *
+ * const todoStore = createPersistedStore(
+ *   'todos',
+ *   {
+ *     todos: [] as Todo[],
+ *     addTodo(text: string) { ... }
+ *   }
+ * );
+ */
+export declare function createPersistedStore<T extends object>(key: string, initialState: T, options?: Omit<PersistOptions<T>, 'key'>): T & {
+    hydrate: () => Promise<void>;
+    clearStorage: () => Promise<void>;
+};
+//# sourceMappingURL=valtio-persist.d.ts.map

package/dist/local-storage/valtio-persist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valtio-persist.d.ts","sourceRoot":"","sources":["../../src/local-storage/valtio-persist.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GACzB;IACD,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC,CA8DA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EACnD,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GACvC,CAAC,GAAG;IACL,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC,CAWA"}

package/dist/local-storage/valtio-persist.js

@@ -0,0 +1,84 @@
+import { isBrowser } from '../utils/helpers';
+import { subscribe } from 'valtio';
+/**
+ * Valtio persistence helper for Next.js with SSR support
+ * Automatically syncs Valtio state with localStorage/sessionStorage
+ */
+export function persist(store, options) {
+    const { key, storage = typeof window !== 'undefined' ? localStorage : undefined, serialize = JSON.stringify, deserialize = JSON.parse, } = options;
+    let isHydrated = false;
+    let unsubscribe = null;
+    // Hydrate store from storage
+    const hydrate = async () => {
+        if (!isBrowser() || !storage || isHydrated) {
+            return;
+        }
+        try {
+            const storedValue = storage.getItem(key);
+            if (storedValue !== null) {
+                const parsed = deserialize(storedValue);
+                // Merge stored values into the store
+                Object.assign(store, parsed);
+            }
+        }
+        catch (error) {
+            console.error(`Failed to hydrate store from key "${key}":`, error);
+        }
+        finally {
+            isHydrated = true;
+        }
+        // Set up persistence after hydration
+        if (!unsubscribe) {
+            unsubscribe = subscribe(store, () => {
+                if (!storage)
+                    return;
+                try {
+                    const serialized = serialize(store);
+                    storage.setItem(key, serialized);
+                }
+                catch (error) {
+                    console.error(`Failed to persist store to key "${key}":`, error);
+                }
+            });
+        }
+    };
+    // Clear storage
+    const clearStorage = async () => {
+        if (!isBrowser() || !storage) {
+            return;
+        }
+        try {
+            storage.removeItem(key);
+        }
+        catch (error) {
+            console.error(`Failed to clear storage for key "${key}":`, error);
+        }
+    };
+    return {
+        hydrate,
+        clearStorage,
+    };
+}
+/**
+ * Create a persisted Valtio store with TypeScript support
+ * Example usage:
+ *
+ * const todoStore = createPersistedStore(
+ *   'todos',
+ *   {
+ *     todos: [] as Todo[],
+ *     addTodo(text: string) { ... }
+ *   }
+ * );
+ */
+export function createPersistedStore(key, initialState, options) {
+    const { hydrate, clearStorage } = persist(initialState, {
+        key,
+        ...options,
+    });
+    return {
+        ...initialState,
+        hydrate,
+        clearStorage,
+    };
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,4 @@
+export type { NavigationMenuItem, NavigationUserContext, PermissionCheckFn, FilteredNavigation, NavigationConfig, } from '../navigation/types';
+export { defaultPermissionCheck, hasPermission, filterNavigationByPermissions, getAccessiblePaths, isPathAccessible, } from '../navigation/permissions';
+export { getNavigationUserContext, getFilteredNavigation, NavigationBuilder } from '../navigation/utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/navigation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/navigation/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,sBAAsB,EACtB,aAAa,EACb,6BAA6B,EAC7B,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/navigation/index.js

@@ -0,0 +1,4 @@
+// Permission utilities
+export { defaultPermissionCheck, hasPermission, filterNavigationByPermissions, getAccessiblePaths, isPathAccessible, } from '../navigation/permissions';
+// Main utilities
+export { getNavigationUserContext, getFilteredNavigation, NavigationBuilder } from '../navigation/utils';