frontend-hamroun 1.2.85 → 1.2.89

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,GAAG,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,aAAa,kDAKxB,CAAC;AAEH,wBAAgB,SAAS,IAAI,kBAAkB,CAE9C;AAED,wBAAgB,WAAW;;;;;EAQ1B;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,KAAK,CAAC,CAGlE;AAED,wBAAgB,WAAW,WAnCR,MAAM,KAAK,IAAI,CAsCjC;AAED,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAA;CAAE,GAAG,GAAG,CA2DnE;AAED,wBAAgB,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,OAYrD;AAwCD,wBAAgB,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG,GAAG,CAetG;AAED,wBAAgB,KAAK,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,GAAG,CAAA;CAAE,QAG1E;AAED,wBAAgB,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAA;CAAE,OAkBrD;;;;;;;;;;;;AAED,wBAUE"}

package/dist/router.js

@@ -0,0 +1,165 @@
+/**
+ * Router implementation for client and server navigation
+ */
+import { useState, useEffect } from './hooks.js';
+import { createContext, useContext } from './context.js';
+import { jsx } from './jsx-runtime.js';
+export const RouterContext = createContext({
+    currentPath: '/',
+    navigate: () => { },
+    params: {},
+    query: {}
+});
+export function useRouter() {
+    return useContext(RouterContext);
+}
+export function useLocation() {
+    const router = useContext(RouterContext);
+    return {
+        pathname: router.currentPath,
+        search: '', // TODO: Implement search parsing
+        hash: '', // TODO: Implement hash parsing
+        state: {} // TODO: Implement history state
+    };
+}
+export function useParams() {
+    const router = useContext(RouterContext);
+    return router.params;
+}
+export function useNavigate() {
+    const router = useContext(RouterContext);
+    return router.navigate;
+}
+export function RouterProvider({ children }) {
+    // Initial path should be window.location.pathname on client, or passed from server context
+    const [currentPath, setCurrentPath] = useState(typeof window !== 'undefined' ? window.location.pathname : '/');
+    const [params, setParams] = useState({});
+    const [query, setQuery] = useState({});
+    // Update path when URL changes
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handlePopState = () => {
+            setCurrentPath(window.location.pathname);
+            parseQuery(window.location.search);
+        };
+        window.addEventListener('popstate', handlePopState);
+        // Parse initial query
+        parseQuery(window.location.search);
+        return () => {
+            window.removeEventListener('popstate', handlePopState);
+        };
+    }, []);
+    // Parse query string into object
+    const parseQuery = (queryString) => {
+        const queryObj = {};
+        if (queryString.startsWith('?')) {
+            queryString = queryString.substring(1);
+        }
+        queryString.split('&').forEach(pair => {
+            if (!pair)
+                return;
+            const [key, value] = pair.split('=');
+            queryObj[decodeURIComponent(key)] = decodeURIComponent(value || '');
+        });
+        setQuery(queryObj);
+    };
+    // Navigate programmatically
+    const navigate = (path) => {
+        if (typeof window === 'undefined')
+            return;
+        window.history.pushState(null, '', path);
+        setCurrentPath(path);
+        parseQuery(window.location.search);
+    };
+    return jsx(RouterContext.Provider, {
+        value: { currentPath, navigate, params, query },
+        children
+    });
+}
+export function Router({ routes }) {
+    const router = useRouter();
+    const currentPath = router.currentPath;
+    // Find matching route
+    const matchedRoute = findMatchingRoute(routes, currentPath);
+    if (!matchedRoute) {
+        return jsx('div', { children: '404 - Page Not Found' });
+    }
+    return matchedRoute.component({ children: matchedRoute.children });
+}
+function findMatchingRoute(routes, path) {
+    for (const route of routes) {
+        const match = matchPath(path, route);
+        if (match) {
+            return {
+                ...route,
+                params: match.params
+            };
+        }
+    }
+    return null;
+}
+function matchPath(pathname, route) {
+    const { path, exact = true } = route;
+    // Convert route pattern to regex
+    const pattern = path.replace(/:[a-zA-Z0-9_]+/g, '([^/]+)');
+    const regex = new RegExp(`^${pattern}${exact ? '$' : ''}`);
+    const match = pathname.match(regex);
+    if (!match) {
+        return null;
+    }
+    // Extract params
+    const params = {};
+    const paramNames = path.match(/:[a-zA-Z0-9_]+/g) || [];
+    paramNames.forEach((paramName, index) => {
+        params[paramName.substring(1)] = match[index + 1];
+    });
+    return { params };
+}
+export function Link({ to, children, ...rest }) {
+    const router = useRouter();
+    const navigate = router.navigate;
+    const handleClick = (e) => {
+        e.preventDefault();
+        navigate(to);
+    };
+    return jsx('a', {
+        href: to,
+        onClick: handleClick,
+        ...rest,
+        children
+    });
+}
+export function Route({ path, component }) {
+    // This is a configuration component, not actually rendered
+    return null;
+}
+export function Switch({ children }) {
+    const router = useRouter();
+    const currentPath = router.currentPath;
+    // Find the first matching route
+    const child = Array.isArray(children)
+        ? children.find(child => {
+            if (!child || !child.props)
+                return false;
+            const routeObj = {
+                path: child.props.path,
+                component: child.props.component,
+                exact: child.props.exact
+            };
+            return matchPath(currentPath, routeObj);
+        })
+        : children;
+    return child || null;
+}
+export default {
+    RouterProvider,
+    Router,
+    Link,
+    Route,
+    Switch,
+    useRouter,
+    useParams,
+    useNavigate,
+    useLocation
+};

package/dist/server-renderer.d.ts

@@ -0,0 +1,2 @@
+export declare function renderToString(element: any): Promise<string>;
+//# sourceMappingURL=server-renderer.d.ts.map

package/dist/server-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-renderer.d.ts","sourceRoot":"","sources":["../src/server-renderer.ts"],"names":[],"mappings":"AAGA,wBAAsB,cAAc,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CASlE"}

package/dist/server-renderer.js

@@ -1,5 +1,111 @@
-import { r } from "./server-renderer-C4MB-jAp.js";
-export {
-  r as renderToString
-};
-//# sourceMappingURL=server-renderer.js.map
+import { prepareRender, finishRender } from './hooks.js';
+export async function renderToString(element) {
+    const renderId = prepareRender(true); // Mark as SSR
+    try {
+        const html = await renderNodeToString(element);
+        return html;
+    }
+    finally {
+        finishRender();
+    }
+}
+async function renderNodeToString(node) {
+    // Handle null, undefined, boolean
+    if (node == null || typeof node === 'boolean') {
+        return '';
+    }
+    // Handle primitives
+    if (typeof node === 'string' || typeof node === 'number') {
+        return escapeHtml(String(node));
+    }
+    // Handle arrays
+    if (Array.isArray(node)) {
+        const results = await Promise.all(node.map(child => renderNodeToString(child)));
+        return results.join('');
+    }
+    // Handle objects with type and props (React-like elements)
+    if (node && typeof node === 'object' && 'type' in node) {
+        const { type, props = {} } = node;
+        // Handle function components
+        if (typeof type === 'function') {
+            try {
+                const result = await type(props);
+                return await renderNodeToString(result);
+            }
+            catch (error) {
+                console.error('Error rendering component:', error);
+                return `<!-- Error rendering component: ${error.message} -->`;
+            }
+        }
+        // Handle DOM elements
+        if (typeof type === 'string') {
+            return await renderDOMElement(type, props);
+        }
+    }
+    // Fallback for other objects
+    if (typeof node === 'object') {
+        return escapeHtml(JSON.stringify(node));
+    }
+    return escapeHtml(String(node));
+}
+async function renderDOMElement(tagName, props) {
+    const { children, ...attrs } = props;
+    // Self-closing tags
+    const voidElements = new Set([
+        'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+        'link', 'meta', 'param', 'source', 'track', 'wbr'
+    ]);
+    // Build attributes string
+    const attributeString = Object.entries(attrs)
+        .filter(([key, value]) => {
+        // Filter out React-specific props and event handlers
+        if (key.startsWith('on') || key === 'key' || key === 'ref')
+            return false;
+        if (value == null || value === false)
+            return false;
+        return true;
+    })
+        .map(([key, value]) => {
+        // Handle className -> class
+        if (key === 'className')
+            key = 'class';
+        // Handle boolean attributes
+        if (value === true)
+            return key;
+        // Handle style objects
+        if (key === 'style' && typeof value === 'object' && value !== null) {
+            const styleString = Object.entries(value)
+                .map(([prop, val]) => `${kebabCase(prop)}:${val}`)
+                .join(';');
+            return `style="${escapeHtml(styleString)}"`;
+        }
+        return `${key}="${escapeHtml(String(value))}"`;
+    })
+        .join(' ');
+    const openTag = `<${tagName}${attributeString ? ' ' + attributeString : ''}>`;
+    // Self-closing elements
+    if (voidElements.has(tagName)) {
+        return openTag.slice(0, -1) + '/>';
+    }
+    // Elements with children
+    const closeTag = `</${tagName}>`;
+    if (children != null) {
+        const childrenString = await renderNodeToString(children);
+        return openTag + childrenString + closeTag;
+    }
+    return openTag + closeTag;
+}
+function escapeHtml(text) {
+    const htmlEscapes = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#x27;',
+        '/': '&#x2F;'
+    };
+    return text.replace(/[&<>"'/]/g, (match) => htmlEscapes[match]);
+}
+function kebabCase(str) {
+    return str.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}

package/dist/server-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Public type definitions for server functionality
+ * These types are safe to import in any environment
+ */
+export interface ServerConfig {
+    port?: number;
+    apiDir?: string;
+    pagesDir?: string;
+    staticDir?: string;
+    enableCors?: boolean;
+    corsOptions?: any;
+    db?: {
+        url: string;
+        type: 'mongodb' | 'mysql' | 'postgres';
+    };
+    auth?: {
+        secret: string;
+        expiresIn?: string;
+    };
+}
+export interface Server {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getExpressApp(): any;
+    getDatabase(): any;
+    getAuth(): any;
+}
+export interface User {
+    id: string | number;
+    username: string;
+    password?: string;
+    email?: string;
+    roles?: string[];
+    [key: string]: any;
+}
+export interface DbConfig {
+    url: string;
+    type: 'mongodb' | 'mysql' | 'postgres';
+}
+export interface MiddlewareFunction {
+    (req: any, res: any, next: any): void | Promise<void>;
+}
+//# sourceMappingURL=server-types.d.ts.map

package/dist/server-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-types.d.ts","sourceRoot":"","sources":["../src/server-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,EAAE,CAAC,EAAE;QACH,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;KACxC,CAAC;IACF,IAAI,CAAC,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,aAAa,IAAI,GAAG,CAAC;IACrB,WAAW,IAAI,GAAG,CAAC;IACnB,OAAO,IAAI,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;CACxC;AAED,MAAM,WAAW,kBAAkB;IACjC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD"}

package/dist/server-types.js

@@ -0,0 +1,5 @@
+/**
+ * Public type definitions for server functionality
+ * These types are safe to import in any environment
+ */
+export {};

package/dist/store.d.ts

@@ -0,0 +1,42 @@
+export interface Action {
+    type: string;
+    payload?: any;
+}
+export type Reducer<S> = (state: S, action: Action) => S;
+export type Selector<S, R> = (state: S) => R;
+export type Dispatch = (action: Action) => void;
+export type Middleware<S> = (store: Store<S>) => (next: Dispatch) => (action: Action) => void;
+export interface Store<S> {
+    getState: () => S;
+    dispatch: Dispatch;
+    subscribe: (listener: () => void) => () => void;
+}
+export interface AsyncAction {
+    (dispatch: Dispatch, getState: () => any): Promise<void> | void;
+}
+export declare function createStore<S>(reducer: Reducer<S>, initialState: S, middlewares?: Middleware<S>[]): Store<S>;
+export interface StoreContextType {
+    store: Store<any>;
+    state: any;
+}
+export declare const StoreContext: import("./types.js").Context<StoreContextType>;
+export declare function StoreProvider<S>({ store, children }: {
+    store: Store<S>;
+    children: any;
+}): any;
+export declare function useSelector<S, R>(selector: Selector<S, R>): R;
+export declare function useDispatch<S>(): Dispatch;
+export declare function useStore<S>(): Store<S>;
+export declare const logger: Middleware<any>;
+export declare const thunk: Middleware<any>;
+declare const _default: {
+    createStore: typeof createStore;
+    StoreProvider: typeof StoreProvider;
+    useSelector: typeof useSelector;
+    useDispatch: typeof useDispatch;
+    useStore: typeof useStore;
+    logger: Middleware<any>;
+    thunk: Middleware<any>;
+};
+export default _default;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC,CAAC;AAEzD,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AAE7C,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAEhD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAE9F,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC,CAAC;IAClB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CACjD;AAGD,MAAM,WAAW,WAAW;IAC1B,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACjE;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,YAAY,EAAE,CAAC,EACf,WAAW,GAAE,UAAU,CAAC,CAAC,CAAC,EAAO,GAChC,KAAK,CAAC,CAAC,CAAC,CAwCV;AAGD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAClB,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,eAAO,MAAM,YAAY,gDAOvB,CAAC;AAEH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAC/B,KAAK,EACL,QAAQ,EACT,EAAE;IACD,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAChB,QAAQ,EAAE,GAAG,CAAC;CACf,GAAG,GAAG,CAeN;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAG7D;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAK,QAAQ,CAGzC;AAED,wBAAgB,QAAQ,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAGtC;AAGD,eAAO,MAAM,MAAM,EAAE,UAAU,CAAC,GAAG,CAQlC,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,UAAU,CAAC,GAAG,CAKjC,CAAC;;;;;;;;;;AAEF,wBAQE"}

package/dist/store.js

@@ -0,0 +1,98 @@
+/**
+ * Global state management solution similar to Redux
+ */
+import { useState, useEffect } from './hooks.js';
+import { createContext, useContext } from './context.js';
+import { jsx } from './jsx-runtime.js';
+export function createStore(reducer, initialState, middlewares = []) {
+    let state = initialState;
+    let listeners = [];
+    // Apply middlewares
+    let dispatch = (action) => {
+        state = reducer(state, action);
+        listeners.forEach(listener => listener());
+        return action;
+    };
+    // Chain middlewares
+    if (middlewares.length > 0) {
+        const middlewareAPI = {
+            getState: () => state,
+            dispatch: (action) => dispatch(action),
+            subscribe: (listener) => subscribe(listener)
+        };
+        const chain = middlewares.map(middleware => middleware(middlewareAPI));
+        dispatch = chain.reduce((a, b) => (next) => a(b(next)))(dispatch);
+    }
+    // Subscribe to store changes
+    function subscribe(listener) {
+        listeners.push(listener);
+        return function unsubscribe() {
+            listeners = listeners.filter(l => l !== listener);
+        };
+    }
+    // Initialize store with default state
+    dispatch({ type: '@@INIT' });
+    return {
+        getState: () => state,
+        dispatch,
+        subscribe
+    };
+}
+export const StoreContext = createContext({
+    store: {
+        getState: () => ({}),
+        dispatch: () => { },
+        subscribe: () => () => { }
+    },
+    state: {}
+});
+export function StoreProvider({ store, children }) {
+    const [state, setState] = useState(store.getState());
+    useEffect(() => {
+        const unsubscribe = store.subscribe(() => {
+            setState(store.getState());
+        });
+        return unsubscribe;
+    }, [store]);
+    return jsx(StoreContext.Provider, {
+        value: { store, state },
+        children
+    });
+}
+export function useSelector(selector) {
+    const context = useContext(StoreContext);
+    return selector(context.state);
+}
+export function useDispatch() {
+    const context = useContext(StoreContext);
+    return context.store.dispatch;
+}
+export function useStore() {
+    const context = useContext(StoreContext);
+    return context.store;
+}
+// Common middlewares
+export const logger = (store) => (next) => (action) => {
+    console.group(action.type);
+    console.log('Previous state:', store.getState());
+    console.log('Action:', action);
+    const result = next(action);
+    console.log('Next state:', store.getState());
+    console.groupEnd();
+    return result;
+};
+export const thunk = (store) => (next) => (action) => {
+    if (typeof action === 'function') {
+        return action(store.dispatch, store.getState);
+    }
+    return next(action);
+};
+export default {
+    createStore,
+    StoreProvider,
+    useSelector,
+    useDispatch,
+    useStore,
+    logger,
+    thunk
+};