jinrai 1.1.2 → 1.1.4

package/lib/src/front/server-state/DataProxy.js

@@ -13,92 +13,154 @@ const getTarget = (data, path) => {
         case "undefined":
         case "symbol":
             // эти типы можно просто завернуть
-            return { value: data };
+            return { $__ROOT__: data };
         default:
             return () => `{{${path}}}`;
     }
 };
-const createDataProxy = (data, path = "") => {
+function createDataProxy(data, path = "") {
     if (path.endsWith("@"))
         sources.set(path.slice(0, -1), data);
     return new Proxy(getTarget(data, path), {
-        get: (_, prop) => {
-            // if (typeof prop == "symbol") return data[prop]
-            if (!(typeof data == "object" && data !== null && prop in data))
-                // DEV TOOLS
+        get: (_target, prop) => {
+            if (ssr.exportToJV) {
+                return {
+                    $JV: {
+                        key: path + "/" + String(prop),
+                        type: "proxy",
+                        def: data,
+                    },
+                };
+            }
+            // ---------------------------
+            // 1. Обработка символов
+            // ---------------------------
+            if (typeof prop === "symbol") {
                 switch (prop) {
-                    // @ts-ignore
                     case Symbol.toPrimitive:
                         return (hint) => {
                             console.log("PROXYDATA", hint);
                             return `{{${path}}}`;
                         };
-                    // @ts-ignore
                     case Symbol.toStringTag:
                         return "Object";
-                    // @ts-ignore
                     case Symbol.iterator:
-                        return data[Symbol.iterator];
-                    case "$$typeof":
-                    case "type":
+                        if (typeof data === "object" && data !== null && Symbol.iterator in data) {
+                            return data[Symbol.iterator];
+                        }
                         return undefined;
-                    case "_debugInfo":
-                        return {
-                            note: `State From Request (${path})`,
-                            kind: typeof data,
-                            timestamp: Date.now(),
-                            preview: data,
-                        };
                 }
-            // SELF
-            if (prop.startsWith("$"))
+            }
+            // ---------------------------
+            // 2. DEV tools
+            // ---------------------------
+            if (!(typeof data === "object" && data !== null && prop in data)) {
+                if (prop === "$$typeof" || prop === "type") {
+                    return undefined;
+                }
+                if (prop === "_debugInfo") {
+                    return {
+                        note: `State From Request (${path})`,
+                        kind: typeof data,
+                        timestamp: Date.now(),
+                        preview: data,
+                    };
+                }
+            }
+            // ---------------------------
+            // 3. SELF: $key → returns function
+            // ---------------------------
+            if (typeof prop === "string" && prop.startsWith("$")) {
                 return (key) => `{{${path + "/" + key}${"\\" + prop}}}`;
-            // TYPES
+            }
+            // ---------------------------
+            // 4. Types special cases
+            // ---------------------------
             switch (typeof data) {
                 case "string":
-                    switch (prop) {
-                        case "length":
-                        case "entries":
-                            return undefined;
-                    }
+                    if (prop === "length" || prop === "entries")
+                        return undefined;
+                    break;
                 case "number":
-                    switch (prop) {
-                        case "@@iterator":
-                            return undefined;
-                    }
+                    if (prop === "@@iterator")
+                        return undefined;
+                    break;
                 default:
-                    switch (prop) {
-                        case "then":
-                            return undefined;
-                    }
+                    if (prop === "then")
+                        return undefined;
             }
-            // OTHER
-            switch (prop) {
-                case "find":
-                    return data[prop];
-                case "map":
-                case "forEach":
-                    return (callback) => React.createElement("loopwrapper", null, [
-                        `ArrayDataKey=${path}|`,
-                        Object.entries(data)
-                            .slice(0, 1)
-                            .map(([key, itm]) => callback(createDataProxy(itm, `${path}/[ITEM=${key}]`))),
-                    ]);
-                case "getValue":
-                    return () => data;
-                case "toJSON":
-                    return () => {
-                        console.log("dataproxy toJSON", path, data);
-                        return ssr.exportParams ? `{{${path}}}` : data;
-                    };
-                default:
-                    if (data && (typeof data[prop] == "object" || Array.isArray(data[prop]))) {
-                        return createDataProxy(data[prop], path + "/" + prop);
-                    }
-                    return `{{${path + "/" + prop}}}`;
+            // ---------------------------
+            // 5. Array-like handlers
+            // ---------------------------
+            if (prop === "find") {
+                return data[prop];
+            }
+            if (prop === "length") {
+                if (Array.isArray(data)) {
+                    return data.length;
+                }
             }
+            if (prop === "map" || prop === "forEach") {
+                return (callback) => React.createElement("loopwrapper", null, [
+                    `ArrayDataKey=${path}|`,
+                    Object.entries(data)
+                        .slice(0, 1)
+                        .map(([key, itm]) => callback(createDataProxy(itm, `${path}/[ITEM=${key}]`))),
+                ]);
+            }
+            // ---------------------------
+            // 6. getValue
+            // ---------------------------
+            if (prop === "getValue") {
+                return () => data;
+            }
+            // ---------------------------
+            // 7. toJSON
+            // ---------------------------
+            if (prop === "toJSON") {
+                return () => {
+                    console.log("dataproxy toJSON", path, data);
+                    return ssr.exportParams
+                        ? `{{${path}}}`
+                        : {
+                            $JV: {
+                                key: path,
+                                type: "proxy",
+                                def: data,
+                                separator: "",
+                            },
+                        };
+                };
+            }
+            // ---------------------------
+            // 8. Nested object
+            // ---------------------------
+            if (data === null) {
+                return undefined;
+            }
+            const value = data[prop];
+            if (!ssr.exportParams) {
+                return value;
+            }
+            if (value && (typeof value === "object" || Array.isArray(value))) {
+                return createDataProxy(value, path + "/" + String(prop));
+            }
+            // if (ssr.exportParams) {
+            // if (typeof value == "string") {
+            //     const key = `{{${path + "/" + String(prop)}}}`
+            //     const jv = getJinraiValue(key, "proxyValue", "", value)
+            //     return value.bindSource(jv)
+            // }
+            //     return key
+            // } else {
+            //     return value
+            // }
+            // ---------------------------
+            // 9. Final primitive fallback
+            // ---------------------------
+            return `{{${path + "/" + String(prop)}}}`;
         },
     });
-};
+}
 
 export { createDataProxy as default, sources };

package/lib/src/front/server-state/SSR.d.ts

@@ -1,4 +1,7 @@
 export declare const ssr: {
     current: boolean;
+    test: boolean;
     exportParams: boolean;
+    exportToJV: boolean;
 };
+export declare const stringifyInput: (input: any) => string;

package/lib/src/front/server-state/SSR.js

@@ -1,6 +1,21 @@
+import { ViteAgent, JinraiAgent } from '../../bin/agent/agent.js';
+
 const ssr = {
-    current: true, //navigator.userAgent == "____JINRAI_CLIENT____",
-    exportParams: false,
+    current: navigator.userAgent == JinraiAgent,
+    // current: true,
+    test: navigator.userAgent == ViteAgent,
+    exportParams: true,
+    exportToJV: false,
+};
+if (window != undefined) {
+    // @ts-ignore
+    window.__ssr = ssr;
+}
+const stringifyInput = (input) => {
+    ssr.exportParams = false;
+    const result = JSON.stringify(input);
+    ssr.exportParams = true;
+    return result;
 };
 
-export { ssr };
+export { ssr, stringifyInput };

package/lib/src/front/server-state/orig.d.ts

@@ -0,0 +1,2 @@
+export declare function orig<T>(value: T): T;
+export declare const original: typeof orig;

package/lib/src/front/server-state/{real.js → orig.js}

@@ -1,11 +1,19 @@
+import { ssr } from './SSR.js';
 import { sources } from './DataProxy.js';
+import { getJinraiValue } from '../url/search/useSearchValue.js';
 
-function real(value) {
+function orig(value) {
+    if (!ssr.current)
+        return value;
     switch (typeof value) {
         case "number":
             return value;
         case "string":
-            return value.startsWith("{{") && value.endsWith("}}") ? getArrayByPath(value.slice(2, -2)) : value;
+            if (value.startsWith("{{") && value.endsWith("}}")) {
+                const result = getArrayByPath(value.slice(2, -2));
+                return wrapSource(result, getJinraiValue(value, "proxy", "", result));
+            }
+            return value;
         case "object":
             // @ts-ignore
             if (value && typeof value.getValue === "function") {
@@ -17,6 +25,13 @@ function real(value) {
             return value;
     }
 }
+const original = orig;
+const wrapSource = (value, source) => {
+    if (typeof value == "string") {
+        return value.bindSource(source);
+    }
+    return value;
+};
 const getArrayByPath = (path) => {
     const [sourceIndex, requestPath] = path.split("@", 2);
     const keys = requestPath.split("/");
@@ -30,4 +45,4 @@ const getArrayByPath = (path) => {
     return link;
 };
 
-export { real };
+export { orig, original };

package/lib/src/front/server-state/serverStates.d.ts

@@ -11,8 +11,10 @@ export type ServerValue = {
             request?: Request;
         };
     };
+    key: ServerKey;
 };
 export declare const serverStates: Map<string, ServerValue>;
+export declare const getIdent: (key: ServerKey) => string;
 export declare const getServerValue: (key?: ServerKey, def?: ServerValue["value"], options?: ServerValue["options"]) => any[];
-export declare const setServerValue: (key: ServerKey, value: ServerValue["value"], options?: ServerValue["options"]) => import("./DataProxy").DataProxy;
+export declare const setServerValue: (key: ServerKey, value: ServerValue["value"], options?: ServerValue["options"]) => any;
 export {};

package/lib/src/front/server-state/serverStates.js

@@ -1,7 +1,16 @@
-import { encode } from 'js-base64';
 import createDataProxy from './DataProxy.js';
-import { ssr } from './SSR.js';
 
+// @ts-ignore
+const initialState = { ...(window?.__appc__?.state ?? {}) };
+// @ts-ignore
+const serverErrors = [...(window?.__appc__?.errors ?? [])];
+if (serverErrors.length) {
+    console.error("SERVER:", serverErrors);
+}
+if (window != undefined) {
+    // @ts-ignore
+    delete window.__appc__;
+}
 const serverStates = new Map();
 if (window != undefined) {
     console.log("init $exportServerStates");
@@ -9,32 +18,30 @@ if (window != undefined) {
     window.$exportServerStates = serverStates;
 }
 const getIdent = (key) => {
-    {
-        ssr.exportParams = true;
-    }
-    const result = Array.isArray(key) ? JSON.stringify(key) : key.toString();
-    {
-        ssr.exportParams = false;
-    }
-    return encode(result);
+    return Array.isArray(key) ? key.join("-") : key;
 };
 const getServerValue = (key, def, options) => {
     if (key == undefined) {
         return [def, false];
     }
     const ident = getIdent(key);
-    serverStates.set(ident, { options, value: !options?.source ? def : undefined });
-    // @ts-ignore
-    if (window != undefined && window?.__serverInitialStates__ && ident in window.__serverInitialStates__) {
-        // @ts-ignore
-        return [window.__serverInitialStates__[ident], true];
+    serverStates.set(ident, { options, value: !options?.source ? def : undefined, key });
+    console.log("CHECK", ident);
+    if (ident in initialState) {
+        const result = initialState[ident];
+        // delete initialState[ident]
+        console.log("HAS", ident, result);
+        if (result != null && typeof result == 'object' && "data" in result) {
+            return [result.data, true];
+        }
+        return [result, true];
     }
     return [def, false];
 };
 const setServerValue = (key, value, options) => {
     const ident = getIdent(key);
-    serverStates.set(ident, { options, value: !options?.source ? value : undefined });
+    serverStates.set(ident, { options, value: !options?.source ? value : undefined, key });
     return createDataProxy(value, `${ident}@`);
 };
 
-export { getServerValue, serverStates, setServerValue };
+export { getIdent, getServerValue, serverStates, setServerValue };

package/lib/src/front/server-state/testState.d.ts

@@ -0,0 +1,3 @@
+import { ServerValue } from "./serverStates";
+import { ServerKey } from "./useServerState";
+export declare const setTestState: (key: ServerKey, value: ServerValue["value"], options?: ServerValue["options"]) => void;

package/lib/src/front/server-state/testState.js

@@ -0,0 +1,14 @@
+import { getIdent } from './serverStates.js';
+import { ssr } from './SSR.js';
+
+const test_states = new Map();
+if (window != undefined && ssr.test) {
+    // @ts-ignore
+    window.$testStates = test_states;
+}
+const setTestState = (key, value, options) => {
+    const ident = getIdent(key);
+    test_states.set(ident, value);
+};
+
+export { setTestState };

package/lib/src/front/server-state/useServerState.d.ts

@@ -2,4 +2,4 @@ import { Dispatch, SetStateAction } from "react";
 import { ServerValue } from "./serverStates";
 export type ServerStateMap = Record<string, ServerValue>;
 export type ServerKey = string | string[];
-export declare const useServerState: <T extends ServerValue["value"]>(serverKey: ServerKey | undefined, initialValue: T, options?: ServerValue["options"]) => [T, Dispatch<SetStateAction<T>>, () => boolean];
+export declare const useServerState: <T extends ServerValue["value"]>(serverKey: ServerKey | undefined, initialValue: T, options?: ServerValue["options"]) => [T, Dispatch<SetStateAction<T>>, boolean];

package/lib/src/front/server-state/useServerState.js

@@ -1,28 +1,24 @@
 import { useState } from 'react';
 import { ssr } from './SSR.js';
 import { getServerValue, setServerValue } from './serverStates.js';
+import { setTestState } from './testState.js';
 
 const useServerState = (serverKey, initialValue, options) => {
     const [serverValue, isInitOnServer] = getServerValue(serverKey, initialValue, options);
     const [value, setStateValue] = useState(serverValue);
-    const [isInit, setIsInit] = useState(isInitOnServer);
     const setValue = (value) => {
         setStateValue((prev) => {
             const result = value instanceof Function ? value(prev) : value;
             if (serverKey != undefined && ssr.current) {
                 return setServerValue(serverKey, result, options);
             }
+            if (serverKey != undefined && ssr.test) {
+                setTestState(serverKey, result);
+            }
             return result;
         });
     };
-    const initOnServer = () => {
-        if (isInit) {
-            setIsInit(false);
-            return true;
-        }
-        return false;
-    };
-    return [value, setValue, initOnServer];
+    return [value, setValue, isInitOnServer];
 };
 
 export { useServerState };

package/lib/src/front/translate/TranslateConfig.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from "react";
+export type DefaultLangType = {
+    defaultLang: string;
+    langBaseUrl: string;
+    source: TranslateSource;
+};
+interface TranslateContextProps {
+    translate: (text: string, context?: string) => string;
+    changeLang: (lang: string) => void;
+    lang: string;
+}
+export declare const useTranslate: () => TranslateContextProps;
+interface TranslateSource {
+    from: "cookie" | "url";
+    key: string;
+}
+type TranslateConfigProps = DefaultLangType & {
+    children: ReactNode;
+};
+export declare const TranslateConfig: ({ children, defaultLang, langBaseUrl, source }: TranslateConfigProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/src/front/translate/TranslateConfig.js

@@ -0,0 +1,108 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useState, useEffect } from 'react';
+import { ssr } from '../server-state/SSR.js';
+
+const TranslateContext = createContext(null);
+const useTranslate = () => {
+    const context = useContext(TranslateContext);
+    if (!context)
+        throw new Error("not in context (<TranslateConfig>)");
+    return context;
+};
+const ONE_DAY = 1000 * 60 * 60 * 24;
+const getCookie = (key) => {
+    const match = document.cookie.match(new RegExp(`(?:^|; )${key.replace(/([$?*|{}()[\]\\/+^])/g, "\\$1")}=([^;]*)`));
+    return match ? decodeURIComponent(match[1]) : null;
+};
+const setCookie = (key, value, days = 365) => {
+    const expires = new Date(Date.now() + days * 864e5).toUTCString();
+    document.cookie = `${key}=${encodeURIComponent(value)}; expires=${expires}; path=/`;
+};
+const getStorageKey = (lang) => `lang:${lang}`;
+const loadFromStorage = (lang) => {
+    try {
+        const raw = localStorage.getItem(getStorageKey(lang));
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        if (Date.now() > parsed.expires) {
+            localStorage.removeItem(getStorageKey(lang));
+            return null;
+        }
+        return parsed.data;
+    }
+    catch {
+        return null;
+    }
+};
+const saveToStorage = (lang, data) => {
+    localStorage.setItem(getStorageKey(lang), JSON.stringify({
+        data,
+        expires: Date.now() + ONE_DAY,
+    }));
+};
+const TranslateConfig = ({ children, defaultLang, langBaseUrl, source }) => {
+    const [lang, setLang] = useState(defaultLang);
+    const [langMap, setLangMap] = useState(null);
+    useEffect(() => {
+        // @ts-ignore
+        window.$langDefaultConfig = {
+            defaultLang,
+            langBaseUrl,
+            source,
+        };
+    }, []);
+    // initial lang from cookie
+    useEffect(() => {
+        if (source.from === "cookie") {
+            const fromCookie = getCookie(source.key);
+            if (fromCookie)
+                setLang(fromCookie);
+        }
+    }, [source.from, source.key]);
+    // load translations on lang change
+    useEffect(() => {
+        if (lang === defaultLang) {
+            setLangMap(null);
+            return;
+        }
+        const cached = loadFromStorage(lang);
+        if (cached) {
+            setLangMap(cached);
+            return;
+        }
+        fetch(langBaseUrl.replace("*", lang))
+            .then(res => {
+            if (!res.ok)
+                throw new Error("Failed to load lang map");
+            return res.json();
+        })
+            .then((data) => {
+            saveToStorage(lang, data);
+            setLangMap(data);
+        })
+            .catch(() => {
+            setLangMap(null);
+        });
+    }, [lang, defaultLang, langBaseUrl]);
+    const translate = (text, context) => {
+        const key = context ? `${text}(context:${context})` : text;
+        if (ssr.current) {
+            return `{!${key}!}`;
+        }
+        if (!langMap)
+            return text;
+        return langMap[key] ?? langMap[text] ?? text;
+    };
+    const changeLang = (nextLang) => {
+        if (nextLang === lang)
+            return;
+        if (source.from === "cookie") {
+            setCookie(source.key, nextLang);
+        }
+        setLang(nextLang);
+    };
+    return jsx(TranslateContext.Provider, { value: { translate, changeLang, lang }, children: children });
+};
+
+export { TranslateConfig, useTranslate };

package/lib/src/front/url/JinraiContext.d.ts

@@ -2,5 +2,6 @@ import { DependencyList, ReactNode } from "react";
 export interface JinraiProps {
     deps?: DependencyList;
     children?: ReactNode;
+    search: string;
 }
 export declare const JinraiContext: import("react").Context<JinraiProps>;

package/lib/src/front/url/JinraiContext.js

@@ -3,6 +3,7 @@ import { createContext } from 'react';
 const JinraiContext = createContext({
     deps: [],
     children: undefined,
+    search: ""
 });
 
 export { JinraiContext };

package/lib/src/front/url/adapter/def.js

@@ -3,7 +3,7 @@ import { JinraiContext } from '../JinraiContext.js';
 import { NuqsAdapter } from 'nuqs/adapters/react';
 
 const Adapter = (props) => {
-    return (jsx(NuqsAdapter, { children: jsx(JinraiContext.Provider, { value: { deps: props.deps ?? [] }, ...props }) }));
+    return (jsx(NuqsAdapter, { children: jsx(JinraiContext.Provider, { value: { deps: props.deps ?? [], search: "" }, ...props }) }));
 };
 
 export { Adapter };

package/lib/src/front/url/adapter/rrd6.js

@@ -7,8 +7,8 @@ const Adapter = (props) => {
     // useLocation требует, чтобы компонент был внутри RouterProvider
     // NuqsAdapter должен быть установлен на верхнем уровне, но может работать внутри роутера
     // для React Router v6 адаптера
-    const { pathname } = useLocation();
-    return (jsx(NuqsAdapter, { children: jsx(JinraiContext.Provider, { value: { deps: [...(props.deps ?? []), pathname] }, ...props }) }));
+    const { pathname, search } = useLocation();
+    return (jsx(NuqsAdapter, { children: jsx(JinraiContext.Provider, { value: { deps: [...(props.deps ?? []), pathname], search: search.substring(1) }, ...props }) }));
 };
 
 export { Adapter };

package/lib/src/front/url/adapter/rrd7.js

@@ -7,8 +7,8 @@ const Adapter = (props) => {
     // useLocation требует, чтобы компонент был внутри RouterProvider
     // NuqsAdapter должен быть установлен на верхнем уровне, но может работать внутри роутера
     // для React Router v7 адаптера
-    const { pathname } = useLocation();
-    return (jsx(NuqsAdapter, { children: jsx(JinraiContext.Provider, { value: { deps: [...(props.deps ?? []), pathname] }, ...props }) }));
+    const { pathname, search } = useLocation();
+    return (jsx(NuqsAdapter, { children: jsx(JinraiContext.Provider, { value: { deps: [...(props.deps ?? []), pathname], search }, ...props }) }));
 };
 
 export { Adapter };

package/lib/src/front/url/params/useParamsIndex.js

@@ -1,12 +1,13 @@
 import { useContext, useMemo } from 'react';
 import { getJinraiValue } from '../search/useSearchValue.js';
 import { JinraiContext } from '../JinraiContext.js';
+import { ssr } from '../../server-state/SSR.js';
 
 const useParamsIndex = (index, def = "") => {
     const { deps } = useContext(JinraiContext);
     const value = useMemo(() => location.pathname.split("/")[index + 1] ?? def, deps ? deps : []);
     const stableValue = useMemo(() => {
-        return value.bindSource(getJinraiValue(index.toString(), "paramsIndex", "", def)) ;
+        return ssr.current ? value.bindSource(getJinraiValue(index.toString(), "paramsIndex", "", def)) : value;
     }, [value]);
     return stableValue;
 };

package/lib/src/front/url/search/useSearch.js

@@ -1,13 +1,13 @@
 import { useContext, useMemo } from 'react';
 import { JinraiContext } from '../JinraiContext.js';
+import { ssr } from '../../server-state/SSR.js';
 import { getJinraiValue } from './useSearchValue.js';
 
 const useSearch = () => {
-    const { deps } = useContext(JinraiContext);
-    const value = useMemo(() => location.search.substring(1), deps ? deps : []);
+    const { search } = useContext(JinraiContext);
     const stableValue = useMemo(() => {
-        return value.bindSource(getJinraiValue("", "search", "", "")) ;
-    }, [value]);
+        return ssr.current ? search.bindSource(getJinraiValue("", "searchFull", "", "")) : search;
+    }, [search]);
     return stableValue;
 };