elit 3.0.1 → 3.0.2

package/src/router.ts

@@ -0,0 +1,237 @@
+/**
+ * Elit - Router - Client-side routing
+ */
+
+import type { VNode, Child, Props, State } from './types';
+import { dom } from './dom';
+
+export interface Route {
+    path: string;
+    component: (params: RouteParams) => VNode | Child;
+    beforeEnter?: (to: RouteLocation, from: RouteLocation | null) => boolean | string | void;
+}
+
+export interface RouteParams {
+    [key: string]: string;
+}
+
+export interface RouteLocation {
+    path: string;
+    params: RouteParams;
+    query: Record<string, string>;
+    hash: string;
+}
+
+export interface RouterOptions {
+    mode?: 'history' | 'hash';
+    base?: string;
+    routes: Route[];
+    notFound?: (params: RouteParams) => VNode | Child;
+}
+
+export interface Router {
+    currentRoute: State<RouteLocation>;
+    push: (path: string) => void;
+    replace: (path: string) => void;
+    back: () => void;
+    forward: () => void;
+    go: (delta: number) => void;
+    beforeEach: (guard: (to: RouteLocation, from: RouteLocation | null) => boolean | string | void) => void;
+    destroy: () => void;
+}
+
+/**
+ * Helper: Match route pattern against path
+ */
+function matchRoute(pattern: string, path: string): RouteParams | null {
+    const patternParts = pattern.split('/').filter(Boolean);
+    const pathParts = path.split('/').filter(Boolean);
+
+    if (pattern.endsWith('*')) {
+        const basePattern = pattern.slice(0, -1);
+        if (path.startsWith(basePattern) || basePattern === '/' || pattern === '*') {
+            return { '*': path.slice(basePattern.length) };
+        }
+    }
+
+    if (patternParts.length !== pathParts.length) return null;
+
+    const params: RouteParams = {};
+    for (let i = 0; i < patternParts.length; i++) {
+        const patternPart = patternParts[i];
+        const pathPart = pathParts[i];
+
+        if (patternPart.startsWith(':')) {
+            params[patternPart.slice(1)] = decodeURIComponent(pathPart);
+        } else if (patternPart !== pathPart) {
+            return null;
+        }
+    }
+    return params;
+}
+
+/**
+ * Helper: Execute guard and handle result (eliminates duplication in navigate)
+ */
+function executeGuard(
+    guard: (to: RouteLocation, from: RouteLocation | null) => boolean | string | void,
+    to: RouteLocation,
+    from: RouteLocation | null,
+    navigate: (path: string, replace?: boolean) => void,
+    replace = false
+): boolean {
+    const result = guard(to, from);
+    if (result === false) return false;
+    if (typeof result === 'string') {
+        navigate(result, replace);
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Helper: Wrap component in VNode if needed (eliminates duplication in createRouterView)
+ */
+function wrapComponent(component: VNode | Child): VNode {
+    if (typeof component === 'object' && component !== null && 'tagName' in component) {
+        return component as VNode;
+    }
+    return { tagName: 'span', props: {}, children: [component] };
+}
+
+export function createRouter(options: RouterOptions): Router {
+    const { mode = 'history', base = '', routes } = options;
+    const globalGuards: Array<(to: RouteLocation, from: RouteLocation | null) => boolean | string | void> = [];
+
+    const parseQuery = (search: string): Record<string, string> => {
+        const query: Record<string, string> = {};
+        const params = new URLSearchParams(search);
+        params.forEach((value, key) => { query[key] = value; });
+        return query;
+    };
+
+    const getCurrentPath = (): string => {
+        if (mode === 'hash') {
+            return window.location.hash.slice(1) || '/';
+        }
+        return window.location.pathname.replace(base, '') || '/';
+    };
+
+    const parseLocation = (path: string): RouteLocation => {
+        const [pathPart, queryPart = ''] = path.split('?');
+        const [cleanPath, hash = ''] = pathPart.split('#');
+        return {
+            path: cleanPath || '/',
+            params: {},
+            query: parseQuery(queryPart),
+            hash: hash ? '#' + hash : ''
+        };
+    };
+
+    const findRoute = (path: string): { route: Route; params: RouteParams } | null => {
+        for (const route of routes) {
+            const params = matchRoute(route.path, path);
+            if (params !== null) {
+                return { route, params };
+            }
+        }
+        return null;
+    };
+
+    const currentRoute = dom.createState<RouteLocation>(parseLocation(getCurrentPath()));
+
+    const navigate = (path: string, replace = false): void => {
+        const location = parseLocation(path);
+        const match = findRoute(location.path);
+
+        if (match) {
+            location.params = match.params;
+        }
+
+        for (const guard of globalGuards) {
+            if (!executeGuard(guard, location, currentRoute.value, navigate, replace)) return;
+        }
+
+        if (match?.route.beforeEnter) {
+            if (!executeGuard(match.route.beforeEnter, location, currentRoute.value, navigate, replace)) return;
+        }
+
+        const url = mode === 'hash' ? '#' + path : base + path;
+        if (replace) {
+            window.history.replaceState({ path }, '', url);
+        } else {
+            window.history.pushState({ path }, '', url);
+        }
+
+        currentRoute.value = location;
+    };
+
+    const handlePopState = (): void => {
+        const path = getCurrentPath();
+        const location = parseLocation(path);
+        const match = findRoute(location.path);
+        if (match) {
+            location.params = match.params;
+        }
+        currentRoute.value = location;
+    };
+
+    if (typeof window !== 'undefined') {
+        window.addEventListener('popstate', handlePopState);
+    }
+
+    return {
+        currentRoute,
+        push: (path: string) => navigate(path, false),
+        replace: (path: string) => navigate(path, true),
+        back: () => window.history.back(),
+        forward: () => window.history.forward(),
+        go: (delta: number) => window.history.go(delta),
+        beforeEach: (guard) => { globalGuards.push(guard); },
+        destroy: () => {
+            if (typeof window !== 'undefined') {
+                window.removeEventListener('popstate', handlePopState);
+            }
+            currentRoute.destroy();
+        }
+    };
+}
+
+// RouterView component - renders current route
+export function createRouterView(router: Router, options: RouterOptions): () => VNode {
+    const { routes, notFound } = options;
+
+    return (): VNode => {
+        const location = router.currentRoute.value;
+        const match = routes.find(r => matchRoute(r.path, location.path) !== null);
+
+        if (match) {
+            const params = matchRoute(match.path, location.path) || {};
+            const component = match.component({ ...params, ...location.query });
+            return wrapComponent(component);
+        }
+
+        if (notFound) {
+            const component = notFound(location.params);
+            return wrapComponent(component);
+        }
+
+        return { tagName: 'div', props: {}, children: ['404 - Not Found'] };
+    };
+}
+
+// Link component - prevents default and uses router
+export const routerLink = (router: Router, props: Props & { to: string }, ...children: Child[]): VNode => {
+    return {
+        tagName: 'a',
+        props: {
+            ...props,
+            href: props.to,
+            onclick: (e: MouseEvent) => {
+                e.preventDefault();
+                router.push(props.to);
+            }
+        },
+        children
+    };
+};

package/src/runtime.ts

@@ -0,0 +1,97 @@
+/**
+ * Runtime detection and global type declarations
+ * Shared across all modules for consistency
+ */
+
+/**
+ * Runtime detection (cached at module load)
+ */
+export const runtime = (() => {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== 'undefined') return 'deno';
+  // @ts-ignore - Bun global
+  if (typeof Bun !== 'undefined') return 'bun';
+  return 'node';
+})() as 'node' | 'bun' | 'deno';
+
+export const isNode = runtime === 'node';
+export const isBun = runtime === 'bun';
+export const isDeno = runtime === 'deno';
+
+// Global declarations for runtime-specific APIs
+declare global {
+  // @ts-ignore - Bun global
+  const Bun: {
+    build(options: {
+      entrypoints: string[];
+      outdir?: string;
+      target?: string;
+      format?: string;
+      minify?: boolean;
+      sourcemap?: string;
+      external?: string[];
+      naming?: string;
+      plugins?: any[];
+      define?: Record<string, string>;
+    }): Promise<{
+      success: boolean;
+      outputs: Array<{ path: string; size: number }>;
+      logs: any[];
+    }>;
+    Transpiler: new (options?: {
+      loader?: string;
+      target?: string;
+      minify?: boolean;
+    }) => {
+      transform(code: string, loader?: string): Promise<string>;
+      transformSync(code: string, loader?: string): string;
+    };
+    file(path: string): {
+      size: number;
+      arrayBuffer(): ArrayBuffer | Promise<ArrayBuffer>;
+      exists(): Promise<boolean>;
+    };
+    write(path: string, data: string | Buffer | Uint8Array): Promise<void>;
+  } | undefined;
+
+  // @ts-ignore - Deno global
+  const Deno: {
+    emit(rootSpecifier: string | URL, options?: {
+      bundle?: 'module' | 'classic';
+      check?: boolean;
+      compilerOptions?: any;
+      importMap?: string;
+      importMapPath?: string;
+      sources?: Record<string, string>;
+    }): Promise<{
+      files: Record<string, string>;
+      diagnostics: any[];
+    }>;
+    writeTextFile(path: string, data: string): Promise<void>;
+    readFile(path: string): Promise<Uint8Array>;
+    readFileSync(path: string): Uint8Array;
+    writeFile(path: string, data: Uint8Array): Promise<void>;
+    writeFileSync(path: string, data: Uint8Array): void;
+    stat(path: string): Promise<any>;
+    statSync(path: string): any;
+    mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+    mkdirSync(path: string, options?: { recursive?: boolean }): void;
+    readDir(path: string): AsyncIterable<any>;
+    readDirSync(path: string): Iterable<any>;
+    remove(path: string, options?: { recursive?: boolean }): Promise<void>;
+    removeSync(path: string, options?: { recursive?: boolean }): void;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    copyFile(src: string, dest: string): Promise<void>;
+    copyFileSync(src: string, dest: string): void;
+    realPath(path: string): Promise<string>;
+    realPathSync(path: string): string;
+    watchFs(paths: string | string[]): AsyncIterable<{
+      kind: string;
+      paths: string[];
+    }>;
+    build: {
+      os: string;
+    };
+  } | undefined;
+}