@vistagenic/vista 0.2.13 → 0.2.15

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Vista.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/server/project-alias-resolver.d.ts

@@ -0,0 +1,4 @@
+export interface ProjectAliasResolver {
+    resolve: (request: string) => string | null;
+}
+export declare function createProjectAliasResolver(cwd: string, resolveFromWorkspace: (specifier: string, cwd: string) => string): ProjectAliasResolver | null;

package/dist/server/project-alias-resolver.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectAliasResolver = createProjectAliasResolver;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const projectAliasCache = new Map();
+function stripJsonComments(input) {
+    let result = '';
+    let inString = false;
+    let stringQuote = '';
+    let isEscaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < input.length; index++) {
+        const current = input[index];
+        const next = input[index + 1];
+        if (inLineComment) {
+            if (current === '\n') {
+                inLineComment = false;
+                result += current;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (current === '*' && next === '/') {
+                inBlockComment = false;
+                index++;
+            }
+            continue;
+        }
+        if (inString) {
+            result += current;
+            if (isEscaped) {
+                isEscaped = false;
+                continue;
+            }
+            if (current === '\\') {
+                isEscaped = true;
+                continue;
+            }
+            if (current === stringQuote) {
+                inString = false;
+                stringQuote = '';
+            }
+            continue;
+        }
+        if ((current === '"' || current === "'") && !inString) {
+            inString = true;
+            stringQuote = current;
+            result += current;
+            continue;
+        }
+        if (current === '/' && next === '/') {
+            inLineComment = true;
+            index++;
+            continue;
+        }
+        if (current === '/' && next === '*') {
+            inBlockComment = true;
+            index++;
+            continue;
+        }
+        result += current;
+    }
+    return result;
+}
+function isBareSpecifier(request) {
+    if (!request)
+        return false;
+    if (request.startsWith('.') || request.startsWith('/'))
+        return false;
+    return !/^[A-Za-z]:[\\/]/.test(request);
+}
+function resolveAliasTargetPath(candidatePath) {
+    const resolvedBase = path_1.default.resolve(candidatePath);
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+    const directCandidates = path_1.default.extname(resolvedBase)
+        ? [resolvedBase]
+        : [resolvedBase, ...extensions.map((extension) => `${resolvedBase}${extension}`)];
+    for (const candidate of directCandidates) {
+        try {
+            if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    try {
+        if (fs_1.default.existsSync(resolvedBase) && fs_1.default.statSync(resolvedBase).isDirectory()) {
+            const packageJsonPath = path_1.default.join(resolvedBase, 'package.json');
+            if (fs_1.default.existsSync(packageJsonPath)) {
+                try {
+                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+                    if (packageJson.main) {
+                        const packageMainPath = resolveAliasTargetPath(path_1.default.join(resolvedBase, packageJson.main));
+                        if (packageMainPath)
+                            return packageMainPath;
+                    }
+                }
+                catch {
+                    // ignore invalid package.json while resolving alias target
+                }
+            }
+            for (const extension of extensions) {
+                const indexPath = path_1.default.join(resolvedBase, `index${extension}`);
+                if (fs_1.default.existsSync(indexPath) && fs_1.default.statSync(indexPath).isFile()) {
+                    return indexPath;
+                }
+            }
+        }
+    }
+    catch {
+        // continue
+    }
+    return null;
+}
+function createProjectAliasResolver(cwd, resolveFromWorkspace) {
+    if (projectAliasCache.has(cwd)) {
+        return projectAliasCache.get(cwd) ?? null;
+    }
+    const configPath = ['tsconfig.json', 'jsconfig.json']
+        .map((filename) => path_1.default.join(cwd, filename))
+        .find((filename) => fs_1.default.existsSync(filename));
+    if (!configPath) {
+        projectAliasCache.set(cwd, null);
+        return null;
+    }
+    let compilerOptions = null;
+    try {
+        const typescriptPath = resolveFromWorkspace('typescript', cwd);
+        const ts = require(typescriptPath);
+        const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+        if (!readResult.error) {
+            compilerOptions = readResult.config?.compilerOptions ?? null;
+        }
+    }
+    catch {
+        // fallback to plain JSON parse below
+    }
+    if (!compilerOptions) {
+        try {
+            const rawConfig = fs_1.default.readFileSync(configPath, 'utf-8');
+            const parsedConfig = JSON.parse(stripJsonComments(rawConfig));
+            compilerOptions = parsedConfig.compilerOptions ?? null;
+        }
+        catch {
+            compilerOptions = null;
+        }
+    }
+    const configDir = path_1.default.dirname(configPath);
+    const rawPaths = compilerOptions?.paths;
+    if (!rawPaths || typeof rawPaths !== 'object') {
+        projectAliasCache.set(cwd, null);
+        return null;
+    }
+    const baseDir = path_1.default.resolve(configDir, typeof compilerOptions?.baseUrl === 'string' && compilerOptions.baseUrl.trim()
+        ? compilerOptions.baseUrl
+        : '.');
+    const exactEntries = new Map();
+    const wildcardEntries = [];
+    for (const [pattern, targetsValue] of Object.entries(rawPaths)) {
+        const targets = Array.isArray(targetsValue)
+            ? targetsValue.filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+            : [];
+        if (targets.length === 0)
+            continue;
+        if (pattern.includes('*')) {
+            const starIndex = pattern.indexOf('*');
+            wildcardEntries.push({
+                prefix: pattern.slice(0, starIndex),
+                suffix: pattern.slice(starIndex + 1),
+                targets,
+            });
+        }
+        else {
+            exactEntries.set(pattern, targets);
+        }
+    }
+    const resolver = {
+        resolve(request) {
+            if (!isBareSpecifier(request))
+                return null;
+            const resolveTargets = (targets, wildcardValue) => {
+                for (const targetPattern of targets) {
+                    const replacedTarget = wildcardValue === undefined ? targetPattern : targetPattern.replace('*', wildcardValue);
+                    const candidate = resolveAliasTargetPath(path_1.default.resolve(baseDir, replacedTarget));
+                    if (candidate) {
+                        return candidate;
+                    }
+                }
+                return null;
+            };
+            const exactMatch = exactEntries.get(request);
+            if (exactMatch) {
+                return resolveTargets(exactMatch);
+            }
+            for (const entry of wildcardEntries) {
+                if (!request.startsWith(entry.prefix) || !request.endsWith(entry.suffix)) {
+                    continue;
+                }
+                const wildcardValue = request.slice(entry.prefix.length, request.length - entry.suffix.length);
+                const resolved = resolveTargets(entry.targets, wildcardValue);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+            return null;
+        },
+    };
+    projectAliasCache.set(cwd, resolver);
+    return resolver;
+}

package/dist/server/rsc-engine.js

@@ -80,6 +80,7 @@ const request_context_1 = require("./request-context");
 const app_router_runtime_1 = require("./app-router-runtime");
 const fetch_policy_1 = require("./fetch-policy");
 const vista_import_map_1 = require("./vista-import-map");
+const project_alias_resolver_1 = require("./project-alias-resolver");
 // Support CSS imports on server runtime
 // - Regular .css: ignored (handled by PostCSS)
 // - .module.css: return empty class mapping (webpack build handles real mappings)
@@ -273,10 +274,15 @@ function installSingleReactResolution(cwd) {
         }
     }
     originalResolveFilename = CjsModule._resolveFilename;
+    const projectAliasResolver = (0, project_alias_resolver_1.createProjectAliasResolver)(cwd, resolveFromWorkspace);
     CjsModule._resolveFilename = function (request, parent, isMain, options) {
         const vistaResolvedPath = resolveVistaInternalRequest(request);
         if (vistaResolvedPath)
             return vistaResolvedPath;
+        const aliasResolvedPath = projectAliasResolver?.resolve(request);
+        if (aliasResolvedPath) {
+            return originalResolveFilename.call(this, aliasResolvedPath, parent, isMain, options);
+        }
         if (request === 'react')
             return reactPath;
         if (request === 'react-dom')

package/dist/server/rsc-upstream.js

@@ -20,6 +20,7 @@ const fetch_policy_1 = require("./fetch-policy");
 const runtime_artifacts_1 = require("./runtime-artifacts");
 const config_1 = require("../config");
 const vista_import_map_1 = require("./vista-import-map");
+const project_alias_resolver_1 = require("./project-alias-resolver");
 // NOTE: RouteErrorBoundary and RouteSuspense are 'use client' components.
 // Under --conditions react-server, React.Component is not available, so we
 // must NOT import them at the top level.  Instead we lazy-require them after
@@ -190,7 +191,7 @@ function isClientBoundaryFile(filename, transpiledSource) {
     clientDirectiveCache.set(filename, isClient);
     return isClient;
 }
-function installSingleReactResolution() {
+function installSingleReactResolution(cwd) {
     if (reactResolutionInstalled)
         return;
     let reactPath;
@@ -203,10 +204,15 @@ function installSingleReactResolution() {
         return;
     }
     originalResolveFilename = CjsModule._resolveFilename;
+    const projectAliasResolver = (0, project_alias_resolver_1.createProjectAliasResolver)(cwd, resolveFromWorkspace);
     CjsModule._resolveFilename = function (request, parent, isMain, options) {
         const vistaResolvedPath = resolveVistaInternalRequest(request);
         if (vistaResolvedPath)
             return vistaResolvedPath;
+        const aliasResolvedPath = projectAliasResolver?.resolve(request);
+        if (aliasResolvedPath) {
+            return originalResolveFilename.call(this, aliasResolvedPath, parent, isMain, options);
+        }
         if (request === 'react')
             return reactPath;
         if (request === 'react-dom')
@@ -472,7 +478,7 @@ function startUpstream() {
     const isDev = process.env.NODE_ENV !== 'production';
     const port = resolvePort(3101);
     const vistaDirRoot = path_1.default.join(cwd, constants_1.BUILD_DIR);
-    installSingleReactResolution();
+    installSingleReactResolution(runtimeRoot);
     setupTypeScriptRuntime(runtimeRoot);
     const flightServerPath = resolveFromWorkspace('react-server-dom-webpack/server.node', cwd);
     const flightServer = require(flightServerPath);

package/dist/server/static-generator.js

@@ -27,6 +27,7 @@ const spawn_permissions_1 = require("./spawn-permissions");
 const config_1 = require("../config");
 const ppr_1 = require("./ppr");
 const vista_import_map_1 = require("./vista-import-map");
+const project_alias_resolver_1 = require("./project-alias-resolver");
 const CjsModule = require('module');
 let staticRuntimeReady = false;
 let reactResolutionInstalled = false;
@@ -72,10 +73,15 @@ function installSingleReactResolution(cwd) {
         }
     }
     originalResolveFilename = CjsModule._resolveFilename;
+    const projectAliasResolver = (0, project_alias_resolver_1.createProjectAliasResolver)(cwd, resolveFromWorkspace);
     CjsModule._resolveFilename = function (request, parent, isMain, options) {
         const vistaResolvedPath = resolveVistaInternalRequest(request);
         if (vistaResolvedPath)
             return vistaResolvedPath;
+        const aliasResolvedPath = projectAliasResolver?.resolve(request);
+        if (aliasResolvedPath) {
+            return originalResolveFilename.call(this, aliasResolvedPath, parent, isMain, options);
+        }
         if (request === 'react')
             return reactPath;
         if (request === 'react-dom')

package/dist/server/typed-api-runtime.js

@@ -22,6 +22,12 @@ const TYPED_API_ENTRYPOINTS = [
     path_1.default.join('app', 'typed-api.js'),
     path_1.default.join('app', 'typed-api.jsx'),
 ];
+const METADATA_ROUTE_MAPPINGS = [
+    { requestPath: '/robots.txt', stem: 'robots' },
+    { requestPath: '/sitemap.xml', stem: 'sitemap' },
+    { requestPath: '/manifest.webmanifest', stem: 'manifest' },
+];
+const ROUTE_FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
 class BodyLimitError extends Error {
     status = 413;
     constructor(limitBytes) {
@@ -82,6 +88,44 @@ function normalizeRouteRequestPath(requestPath) {
     }
     return normalized.replace(/^\/+/, '').replace(/\/+$/, '');
 }
+function isRouteGroupDirectory(name) {
+    return /^\([\w-]+\)$/.test(name);
+}
+function resolveMetadataRoutePath(cwd, stem) {
+    const appDir = path_1.default.resolve(cwd, 'app');
+    const tryStemInDirectory = (dir) => {
+        for (const extension of ROUTE_FILE_EXTENSIONS) {
+            const candidate = path_1.default.join(dir, `${stem}${extension}`);
+            if (fs_1.default.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    };
+    const directMatch = tryStemInDirectory(appDir);
+    if (directMatch) {
+        return directMatch;
+    }
+    const searchGroupDirectories = (dir) => {
+        const entries = fs_1.default
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && isRouteGroupDirectory(entry.name))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const groupDir = path_1.default.join(dir, entry.name);
+            const match = tryStemInDirectory(groupDir);
+            if (match) {
+                return match;
+            }
+            const nestedMatch = searchGroupDirectories(groupDir);
+            if (nestedMatch) {
+                return nestedMatch;
+            }
+        }
+        return null;
+    };
+    return searchGroupDirectories(appDir);
+}
 function hasMethodMatch(router, pathname, method) {
     const normalized = method.toLowerCase();
     return router.resolve(pathname, normalized) !== null;
@@ -307,6 +351,13 @@ function resolveLegacyApiRoutePath(cwd, requestPath) {
 function resolveLegacyRouteHandlerPath(cwd, requestPath) {
     const normalized = normalizeRouteRequestPath(requestPath);
     const routeCandidates = [];
+    const metadataRoute = METADATA_ROUTE_MAPPINGS.find((entry) => entry.requestPath === String(requestPath || '').split('?')[0]);
+    if (metadataRoute) {
+        const resolvedMetadataPath = resolveMetadataRoutePath(cwd, metadataRoute.stem);
+        if (resolvedMetadataPath) {
+            routeCandidates.push(resolvedMetadataPath);
+        }
+    }
     if (normalized.startsWith('api/')) {
         const apiRoute = normalized.slice('api/'.length);
         routeCandidates.push(path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.ts'), path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.tsx'), path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.js'), path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.jsx'), path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.ts`), path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.tsx`), path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.js`), path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.jsx`));

package/dist/theme/index.d.ts

@@ -0,0 +1,2 @@
+export { ThemeProvider, applyTheme, useTheme, type ResolvedTheme, type ThemeMode } from './theme-provider';
+export { ThemeScript } from './theme-script';

package/dist/theme/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeScript = exports.useTheme = exports.applyTheme = exports.ThemeProvider = void 0;
+var theme_provider_1 = require("./theme-provider");
+Object.defineProperty(exports, "ThemeProvider", { enumerable: true, get: function () { return theme_provider_1.ThemeProvider; } });
+Object.defineProperty(exports, "applyTheme", { enumerable: true, get: function () { return theme_provider_1.applyTheme; } });
+Object.defineProperty(exports, "useTheme", { enumerable: true, get: function () { return theme_provider_1.useTheme; } });
+var theme_script_1 = require("./theme-script");
+Object.defineProperty(exports, "ThemeScript", { enumerable: true, get: function () { return theme_script_1.ThemeScript; } });

package/dist/theme/theme-provider.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+export type ThemeMode = 'system' | 'light' | 'dark';
+export type ResolvedTheme = 'light' | 'dark';
+interface ThemeContextValue {
+    theme: ThemeMode;
+    resolvedTheme: ResolvedTheme;
+    setTheme: (theme: ThemeMode) => void;
+    cycleTheme: () => void;
+    mounted: boolean;
+}
+export declare function applyTheme(theme: ThemeMode): void;
+interface ThemeProviderProps {
+    children: ReactNode;
+    defaultTheme?: ThemeMode;
+}
+export declare function ThemeProvider({ children, defaultTheme, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTheme(): ThemeContextValue;
+export {};

package/dist/theme/theme-provider.js

@@ -0,0 +1,112 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTheme = applyTheme;
+exports.ThemeProvider = ThemeProvider;
+exports.useTheme = useTheme;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const THEME_STORAGE_KEY = 'vista-theme';
+const THEME_ORDER = ['system', 'light', 'dark'];
+const MEDIA_QUERY = '(prefers-color-scheme: dark)';
+const ThemeContext = (0, react_1.createContext)(null);
+function sanitizeTheme(value, fallback) {
+    if (value === 'system' || value === 'light' || value === 'dark') {
+        return value;
+    }
+    return fallback;
+}
+function getSystemTheme() {
+    if (typeof window === 'undefined') {
+        return 'dark';
+    }
+    return window.matchMedia(MEDIA_QUERY).matches ? 'dark' : 'light';
+}
+function resolveTheme(theme) {
+    return theme === 'system' ? getSystemTheme() : theme;
+}
+function applyTheme(theme) {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const resolvedTheme = resolveTheme(theme);
+    const root = document.documentElement;
+    root.classList.remove('light', 'dark');
+    root.classList.add(resolvedTheme);
+    root.dataset.theme = theme;
+    root.style.colorScheme = resolvedTheme;
+}
+function ThemeProvider({ children, defaultTheme = 'system', }) {
+    const [theme, setThemeState] = (0, react_1.useState)(defaultTheme);
+    const [mounted, setMounted] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        const nextTheme = sanitizeTheme(window.localStorage.getItem(THEME_STORAGE_KEY), defaultTheme);
+        setThemeState(nextTheme);
+        applyTheme(nextTheme);
+        setMounted(true);
+    }, [defaultTheme]);
+    (0, react_1.useEffect)(() => {
+        if (!mounted)
+            return;
+        window.localStorage.setItem(THEME_STORAGE_KEY, theme);
+        applyTheme(theme);
+    }, [mounted, theme]);
+    (0, react_1.useEffect)(() => {
+        if (!mounted)
+            return;
+        const media = window.matchMedia(MEDIA_QUERY);
+        const handleMediaChange = () => {
+            const currentTheme = sanitizeTheme(window.localStorage.getItem(THEME_STORAGE_KEY), defaultTheme);
+            if (currentTheme === 'system') {
+                applyTheme('system');
+            }
+        };
+        const handleStorage = (event) => {
+            if (event.key !== THEME_STORAGE_KEY)
+                return;
+            const nextTheme = sanitizeTheme(event.newValue, defaultTheme);
+            setThemeState(nextTheme);
+            applyTheme(nextTheme);
+        };
+        if (typeof media.addEventListener === 'function') {
+            media.addEventListener('change', handleMediaChange);
+        }
+        else {
+            media.addListener(handleMediaChange);
+        }
+        window.addEventListener('storage', handleStorage);
+        return () => {
+            if (typeof media.removeEventListener === 'function') {
+                media.removeEventListener('change', handleMediaChange);
+            }
+            else {
+                media.removeListener(handleMediaChange);
+            }
+            window.removeEventListener('storage', handleStorage);
+        };
+    }, [defaultTheme, mounted]);
+    const setTheme = (0, react_1.useCallback)((nextTheme) => {
+        setThemeState(nextTheme);
+    }, []);
+    const cycleTheme = (0, react_1.useCallback)(() => {
+        setThemeState((currentTheme) => {
+            const index = THEME_ORDER.indexOf(currentTheme);
+            return THEME_ORDER[(index + 1) % THEME_ORDER.length];
+        });
+    }, []);
+    const value = (0, react_1.useMemo)(() => ({
+        theme,
+        resolvedTheme: resolveTheme(theme),
+        setTheme,
+        cycleTheme,
+        mounted,
+    }), [cycleTheme, mounted, setTheme, theme]);
+    return (0, jsx_runtime_1.jsx)(ThemeContext.Provider, { value: value, children: children });
+}
+function useTheme() {
+    const context = (0, react_1.useContext)(ThemeContext);
+    if (!context) {
+        throw new Error('useTheme must be used within a ThemeProvider.');
+    }
+    return context;
+}

package/dist/theme/theme-script.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeMode } from './theme-provider';
+interface ThemeScriptProps {
+    defaultTheme?: ThemeMode;
+}
+export declare function ThemeScript({ defaultTheme }: ThemeScriptProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/theme/theme-script.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeScript = ThemeScript;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const THEME_STORAGE_KEY = 'vista-theme';
+const WINDOW_ACCESS = "Function('return this')()";
+const ROOT_ELEMENT_ACCESS = "runtime['doc'+'ument'].documentElement";
+const STORAGE_ACCESS = "runtime['local'+'Storage']";
+function getThemeScript(defaultTheme) {
+    return `(function(){var runtime=${WINDOW_ACCESS};var storageKey='${THEME_STORAGE_KEY}';var defaultTheme='${defaultTheme}';var mediaQuery='(prefers-color-scheme: dark)';function sanitize(value){return value==='system'||value==='light'||value==='dark'?value:defaultTheme;}function resolve(theme){if(theme==='system'){return runtime.matchMedia(mediaQuery).matches?'dark':'light';}return theme;}function apply(theme){var resolved=resolve(theme);var root=${ROOT_ELEMENT_ACCESS};root.classList.remove('light','dark');root.classList.add(resolved);root.dataset.theme=theme;root.style.colorScheme=resolved;}var stored=sanitize(${STORAGE_ACCESS}.getItem(storageKey));apply(stored);}());`;
+}
+function ThemeScript({ defaultTheme = 'system' }) {
+    return ((0, jsx_runtime_1.jsx)("script", { dangerouslySetInnerHTML: {
+            __html: getThemeScript(defaultTheme),
+        } }));
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@vistagenic/vista",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "The React Framework for Visionaries - Rust-powered SSR with Server Components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vistagen/Vista-Js.git",
+    "url": "git+https://github.com/vistakit/Vista-Js.git",
     "directory": "packages/vista"
   },
   "author": "Vista Team",
@@ -68,6 +68,10 @@
       "types": "./dist/font/local.d.ts",
       "default": "./dist/font/local.js"
     },
+    "./theme": {
+      "types": "./dist/theme/index.d.ts",
+      "default": "./dist/theme/index.js"
+    },
     "./head": {
       "react-server": "./dist/client/head.react-server.js",
       "types": "./dist/client/head.d.ts",
@@ -144,5 +148,6 @@
     "@types/webpack": "^5.28.5",
     "@types/webpack-hot-middleware": "^2.25.9",
     "typescript": "^5.7.2"
-  }
+  },
+  "gitHead": "9397c476040f8e0e79fba153a3f05bea5c7bdab9"
 }