@nemigo/svelte 0.3.4 → 1.5.0

package/dist/loader.d.ts

@@ -1,15 +1,55 @@
-export type LoaderHook = ReturnType<LoaderStore["hook"]>;
-export declare class LoaderStore {
-    state: import("./value.svelte.js").ValueStateType<boolean>;
-    private queue;
-    private caller;
-    _hydratable: boolean;
-    constructor(hydratable?: boolean);
-    private check;
-    private awaiter;
-    private reset;
-    push(promise: Promise<unknown>): void;
-    hook(): () => void;
-    run<T = any>(call: () => Promise<T>, external?: (v: boolean) => void): Promise<T>;
+import type { ISvelteState } from "./state.svelte.js";
+import { Loader } from "@nemigo/helpers/async/loader";
+import type { IState } from "@nemigo/helpers/types";
+export type { LoaderHook } from "@nemigo/helpers/async/loader";
+/**
+ * Менеджер состояния выполнения для асинхронных операций.
+ * Поддерживает гидратацию true-значения после SSR
+ *
+ * @example
+ * ```typescript
+ * // Создание экземпляра
+ * const loader = new LoaderStore(true); // в SSR значение будет true
+ *
+ * loader.hydrate(); // Если значение состояния `true`, добавляет onMount-проверку должно ли оно быть таковым
+ *
+ * $effect(() => {
+ *   if (loader.state()) {
+ *     console.log("Loading...");
+ *   } else {
+ *     console.log("Not loading");
+ *   }
+ * });
+ *
+ * // Передача промиса
+ * async function fetchData() {
+ *   const promise = fetch("/api/data");
+ *   loader.push(promise);
+ *   const data = await promise;
+ *   return data;
+ * }
+ *
+ * // Запуск операции
+ * async function fetchData() {
+ *   const data = await loader.run(() => fetch("/api/data"));
+ *   return data;
+ * }
+ *
+ * // Ручное хук (создаёт промис внутри)
+ * const complete = loader.hook();
+ * try {
+ *   await someAsyncOperation();
+ * } finally {
+ *   complete();
+ * }
+ * ```
+ */
+export declare class LoaderStore<State extends IState<boolean> = ISvelteState<boolean>> extends Loader {
+    state: State;
+    static default(init?: boolean): LoaderStore<ISvelteState<boolean>>;
+    constructor(state: State);
+    /**
+     * Создаёт {@link onMount} проверку, если в стейте значение `true`
+     */
     hydrate(): this;
 }

package/dist/loader.js

@@ -1,65 +1,65 @@
-import { ValueState } from "./value.svelte.js";
-import { delay } from "@nemigo/helpers/async";
-import { isSSR } from "@nemigo/helpers/html";
+import { createSvelteState } from "./state.svelte.js";
+import { Loader } from "@nemigo/helpers/async/loader";
 import { onMount } from "svelte";
-export class LoaderStore {
-    state = ValueState(false);
-    queue = [];
-    caller = 0;
-    _hydratable;
-    constructor(hydratable = false) {
-        this._hydratable = hydratable;
-        this.state.set(this._hydratable);
+/**
+ * Менеджер состояния выполнения для асинхронных операций.
+ * Поддерживает гидратацию true-значения после SSR
+ *
+ * @example
+ * ```typescript
+ * // Создание экземпляра
+ * const loader = new LoaderStore(true); // в SSR значение будет true
+ *
+ * loader.hydrate(); // Если значение состояния `true`, добавляет onMount-проверку должно ли оно быть таковым
+ *
+ * $effect(() => {
+ *   if (loader.state()) {
+ *     console.log("Loading...");
+ *   } else {
+ *     console.log("Not loading");
+ *   }
+ * });
+ *
+ * // Передача промиса
+ * async function fetchData() {
+ *   const promise = fetch("/api/data");
+ *   loader.push(promise);
+ *   const data = await promise;
+ *   return data;
+ * }
+ *
+ * // Запуск операции
+ * async function fetchData() {
+ *   const data = await loader.run(() => fetch("/api/data"));
+ *   return data;
+ * }
+ *
+ * // Ручное хук (создаёт промис внутри)
+ * const complete = loader.hook();
+ * try {
+ *   await someAsyncOperation();
+ * } finally {
+ *   complete();
+ * }
+ * ```
+ */
+export class LoaderStore extends Loader {
+    state;
+    static default(init = false) {
+        return new LoaderStore(createSvelteState(init));
     }
-    check(caller) {
-        if (this.queue.length === 0)
-            return this.reset(caller);
-        void Promise.allSettled(this.queue).then(() => {
-            if (this.caller !== caller)
-                return;
-            void delay(20).then(() => this.reset(caller));
-        });
-    }
-    awaiter(caller) {
-        this.state.set(true);
-        this.check(caller);
-    }
-    reset(caller) {
-        if (this.caller !== caller)
-            return;
-        this.state.set(false);
-        this.caller = 0;
-        this.queue = [];
-    }
-    push(promise) {
-        this.caller++;
-        this.queue.push(promise);
-        this.awaiter(this.caller);
-    }
-    hook() {
-        if (isSSR)
-            return () => { };
-        let resolver;
-        const promise = new Promise((resolve) => (resolver = resolve));
-        this.push(promise);
-        return resolver;
-    }
-    async run(call, external) {
-        const hook = this.hook();
-        external?.(true);
-        try {
-            return await call();
-        }
-        finally {
-            external?.(false);
-            hook();
-        }
+    constructor(state) {
+        super((v) => state.set(v));
+        this.state = state;
     }
+    /**
+     * Создаёт {@link onMount} проверку, если в стейте значение `true`
+     */
     hydrate() {
-        if (this._hydratable) {
+        if (this.state.get()) {
             onMount(() => {
-                if (this.state.value)
-                    this.check(this.caller);
+                if (this.state.get())
+                    this.__check(this.__version);
             });
         }
         return this;

package/dist/state.svelte.d.ts

@@ -0,0 +1,42 @@
+import type { IState } from "@nemigo/helpers/types";
+/**
+ * Интерфейс $state-хранилища значения из {@link createSvelteState}
+ */
+export interface ISvelteState<V = boolean | undefined> extends IState<V> {
+    /**
+     * @reactive
+     */
+    signal: V;
+    /**
+     * Получает текущее значение состояния без подписки на изменения.
+     */
+    get(): V;
+    /**
+     * Безопасно устанавливает новое значение состояния (внутри {@link untrack}).
+     */
+    set(state: V): void;
+    /**
+     * Вызов коллбэка внутри {@link untrack}
+     */
+    untrack<R>(call: (state: V) => R): R;
+}
+/**
+ * Создание $state-хранилища значения
+ *
+ * @template T - Тип значения
+ * @return {ISvelteState<T | undefined>}
+ *
+ * @see https://svelte.dev/docs/svelte/what-are-runes
+ */
+declare function createSvelteState<T = boolean>(): ISvelteState<T | undefined>;
+/**
+ * Создание $state-хранилища значения
+ *
+ * @template T - Тип значения
+ * @param {T} initial
+ * @return {ISvelteState<T>}
+ *
+ * @see https://svelte.dev/docs/svelte/what-are-runes
+ */
+declare function createSvelteState<T = boolean>(initial: T): ISvelteState<T>;
+export { createSvelteState };

package/dist/state.svelte.js

@@ -0,0 +1,33 @@
+import { untrack } from "svelte";
+/**
+ * Создание $state-хранилища значения
+ *
+ * @template T - Тип значения
+ * @param {T} [initial]
+ * @return {ISvelteState<T | undefined>}
+ *
+ * @see https://svelte.dev/docs/svelte/what-are-runes
+ */
+function createSvelteState(initial) {
+    let signal = $state(initial);
+    return {
+        get signal() {
+            return signal;
+        },
+        set signal(state) {
+            signal = state;
+        },
+        get() {
+            return untrack(() => signal);
+        },
+        set(state) {
+            untrack(() => {
+                signal = state;
+            });
+        },
+        untrack(call) {
+            return untrack(() => call(signal));
+        },
+    };
+}
+export { createSvelteState };

package/dist/transitions.js

@@ -1,4 +1,4 @@
-import { toRound } from "@nemigo/helpers/phymath";
+import { round } from "@nemigo/helpers/phymath";
 import { linear, quadInOut, quadOut } from "svelte/easing";
 import { slide as svelte_slide } from "svelte/transition";
 export const classNameTransition = (node, { animationClassName, reverseDirectionStyle = "reverse", normalDirectionStyle = "", duration = 325 }) => {
@@ -89,12 +89,12 @@ export function slide(node, { delay = 0, duration = 325, easing, axis = "y", cla
 	      overflow: hidden;
 	      opacity: ${delayed};
 	      ${prop}: ${boosted * propValue}px;
-	      padding-${secProps[0]}: ${toRound(boosted * padStart, 4)}px;
-	      padding-${secProps[1]}: ${toRound(boosted * padEnd, 4)}px;
-	      margin-${secProps[0]}: ${toRound(boosted * marStart, 4)}px;
-	      margin-${secProps[1]}: ${toRound(boosted * marEnd, 4)}px;
-	      border-${secProps[0]}-width: ${toRound(boosted * borStart, 4)}px;
-	      border-${secProps[1]}-width: ${toRound(boosted * borEnd, 4)}px;
+	      padding-${secProps[0]}: ${round(boosted * padStart, 4)}px;
+	      padding-${secProps[1]}: ${round(boosted * padEnd, 4)}px;
+	      margin-${secProps[0]}: ${round(boosted * marStart, 4)}px;
+	      margin-${secProps[1]}: ${round(boosted * marEnd, 4)}px;
+	      border-${secProps[0]}-width: ${round(boosted * borStart, 4)}px;
+	      border-${secProps[1]}-width: ${round(boosted * borEnd, 4)}px;
 	      min-${prop}: 0
 	    `;
         },
@@ -141,8 +141,8 @@ export const upper = (node, { delay = 0, duration = 400, x = 0, y = 0, opacity =
         easing: quadOut,
         css: (t, u) => {
             return `
-					transform: scale(${toRound(0.6 + t / 2.5, 5)}) translate(${toRound((1 - t) * x)}px, ${toRound((1 - t) * y)}px);
-					opacity: ${toRound(target_opacity - od * u)};
+					transform: scale(${round(0.6 + t / 2.5, 5)}) translate(${round((1 - t) * x)}px, ${round((1 - t) * y)}px);
+					opacity: ${round(target_opacity - od * u)};
 			`;
         },
     };
@@ -154,5 +154,5 @@ export const fontSizeScale = (_, { delay = 0, duration = 300, easing = linear }
     delay,
     duration,
     easing,
-    css: (t) => `font-size:${toRound(t, 3)}em;will-change:font-size`,
+    css: (t) => `font-size:${round(t, 3)}em;will-change:font-size`,
 });

package/package.json

@@ -1,12 +1,16 @@
 {
 	"name": "@nemigo/svelte",
-	"version": "0.3.4",
+	"version": "1.5.0",
 	"private": false,
 	"author": {
 		"name": "Vlad Logvin",
 		"email": "vlad.logvin84@gmail.com"
 	},
 	"type": "module",
+	"engines": {
+		"node": ">=22",
+		"pnpm": ">=10.9.0"
+	},
 	"scripts": {
 		"build": "svelte-package && rimraf .svelte-kit",
 		"check": "tsc --noemit",
@@ -15,12 +19,8 @@
 	},
 	"exports": {
 		".": {
-			"types": "./dist/value.svelte.d.ts",
-			"svelte": "./dist/value.svelte.js"
-		},
-		"./kit/state": {
-			"types": "./dist/kit/state.d.ts",
-			"svelte": "./dist/kit/state.js"
+			"types": "./dist/state.svelte.d.ts",
+			"svelte": "./dist/state.svelte.js"
 		},
 		"./loader": {
 			"types": "./dist/loader.d.ts",
@@ -32,9 +32,9 @@
 		}
 	},
 	"peerDependencies": {
-		"@nemigo/helpers": ">0.3.0",
-		"@sveltejs/kit": "^2.12.0",
-		"svelte": "^5.0.0"
+		"@nemigo/helpers": ">=1.5.0",
+		"@sveltejs/kit": ">=2.12.0",
+		"svelte": ">=5.0.0"
 	},
 	"peerDependenciesMeta": {
 		"@sveltejs/kit": {
@@ -42,7 +42,7 @@
 		}
 	},
 	"dependencies": {
-		"csstype": "^3.0.0"
+		"csstype": ">=3.0.0"
 	},
 	"devDependencies": {
 		"@nemigo/configs": "workspace:*",

package/dist/kit/state.d.ts

@@ -1,59 +0,0 @@
-import { Queue } from "@nemigo/helpers/queue";
-import type { CanBePromise } from "@nemigo/helpers/types";
-import type { Params } from "@nemigo/helpers/url";
-interface QueueItem {
-    method: "close" | "open";
-    state: App.PageState;
-    params: Params;
-    call?: () => CanBePromise;
-}
-declare class StateCTX extends Queue<QueueItem> {
-    /**
-     * Возвращает текущее мета-состояние страницы
-     */
-    get(clone?: boolean): App.PageState;
-    set(v: App.PageState): void;
-    hook(call: () => Promise<void>): Promise<void>;
-    /**
-     * Объединяет несколько состояний в одно
-     */
-    private join;
-    /**
-     * Безопасно от прокси добавляет новое состояние в историю браузера
-     */
-    pushStateSafe(url: string | URL, ctate?: App.PageState): void;
-    /**
-     * Безопасно от прокси заменяет текущее состояние в истории браузера
-     */
-    replaceStateSafe(url: string | URL, ctate?: App.PageState): void;
-    /**
-     * Возвращает текущий URL
-     */
-    getCurrentURL(): URL;
-    /**
-     * Преобразует абсолютный URL в относительный
-     */
-    toRelative(url: URL): string;
-    /**
-     * Очищает указанные параметры из текущего URL
-     */
-    clearParams(params: Params): string;
-    /**
-     * Добавляет указанные параметры в текущий URL
-     */
-    pushParams(params: Params): string;
-    /**
-     * Открывает новое мета-состояние с указанными параметрами
-     */
-    open(ctate: App.PageState, params?: Params, call?: () => CanBePromise): void;
-    /**
-     * Закрывает текущее мета-состояние с указанными параметрами
-     */
-    close(ctate: App.PageState, params?: Params, call?: () => CanBePromise): void;
-    /**
-     * Обработка очереди состояния
-     */
-    protected handle(item: QueueItem): void;
-}
-export type { StateCTX };
-export declare const stateCTX: StateCTX;

package/dist/kit/state.js

@@ -1,118 +0,0 @@
-import { pushState, replaceState } from "$app/navigation";
-import { page } from "$app/state";
-import { parsify } from "@nemigo/helpers";
-import { isSSR } from "@nemigo/helpers/html";
-import { Queue } from "@nemigo/helpers/queue";
-import { clearParams, mergeClearParams, pushParams } from "@nemigo/helpers/url";
-import { tick } from "svelte";
-class StateCTX extends Queue {
-    /**
-     * Возвращает текущее мета-состояние страницы
-     */
-    get(clone = false) {
-        if (isSSR)
-            return {};
-        return clone ? parsify(page.state) : page.state;
-    }
-    set(v) {
-        replaceState("", parsify(v));
-    }
-    async hook(call) {
-        const copy = parsify(page.state);
-        await call();
-        replaceState("", copy);
-    }
-    /**
-     * Объединяет несколько состояний в одно
-     */
-    join(...states) {
-        return states.reduce((acc, ctate) => ({ ...acc, ...ctate }), {});
-    }
-    //...
-    /**
-     * Безопасно от прокси добавляет новое состояние в историю браузера
-     */
-    pushStateSafe(url, ctate = this.get()) {
-        // eslint-disable-next-line svelte/no-navigation-without-resolve
-        pushState(url, parsify(ctate));
-    }
-    /**
-     * Безопасно от прокси заменяет текущее состояние в истории браузера
-     */
-    replaceStateSafe(url, ctate = this.get()) {
-        // eslint-disable-next-line svelte/no-navigation-without-resolve
-        replaceState(url, parsify(ctate));
-    }
-    //...
-    /**
-     * Возвращает текущий URL
-     */
-    getCurrentURL() {
-        return new URL(window.location.href);
-    }
-    /**
-     * Преобразует абсолютный URL в относительный
-     */
-    toRelative(url) {
-        return url.toString().replace(url.origin, "");
-    }
-    //...
-    /**
-     * Очищает указанные параметры из текущего URL
-     */
-    clearParams(params) {
-        return this.toRelative(clearParams(this.getCurrentURL(), params));
-    }
-    /**
-     * Добавляет указанные параметры в текущий URL
-     */
-    pushParams(params) {
-        return this.toRelative(pushParams(this.getCurrentURL(), params, true));
-    }
-    //...
-    /**
-     * Открывает новое мета-состояние с указанными параметрами
-     */
-    open(ctate, params = [], call) {
-        this.push({ method: "open", state: ctate, params, call });
-    }
-    /**
-     * Закрывает текущее мета-состояние с указанными параметрами
-     */
-    close(ctate, params = [], call) {
-        if (this._queue.length > 0) {
-            const last = this._queue[this._queue.length - 1];
-            if (last.method === "close") {
-                last.state = this.join(last.state, ctate);
-                last.params = mergeClearParams(last.params, params);
-                if (call) {
-                    if (last.call) {
-                        last.call = () => {
-                            last.call?.();
-                            call();
-                        };
-                    }
-                    else {
-                        last.call = call;
-                    }
-                }
-                return;
-            }
-        }
-        this.push({ method: "close", state: ctate, params, call });
-    }
-    /**
-     * Обработка очереди состояния
-     */
-    handle(item) {
-        const ctate = this.join(this.get(), item.state);
-        if (item.method === "open") {
-            this.pushStateSafe(this.pushParams(item.params), ctate);
-        }
-        else {
-            this.replaceStateSafe(this.clearParams(item.params), ctate);
-        }
-        void tick().then(() => item.call?.());
-    }
-}
-export const stateCTX = new StateCTX();

package/dist/value.svelte.d.ts

@@ -1,12 +0,0 @@
-export interface ValueStateType<T = boolean | undefined> {
-    /**
-     * @reactive
-     */
-    value: T;
-    get(): T;
-    set(state: T): void;
-    untrack<R>(call: (state: T) => R): R;
-}
-declare function ValueState<T = boolean>(): ValueStateType<T | undefined>;
-declare function ValueState<T = boolean>(initial: T): ValueStateType<T>;
-export { ValueState };

package/dist/value.svelte.js

@@ -1,24 +0,0 @@
-import { untrack } from "svelte";
-function ValueState(initial) {
-    let _value = $state(initial);
-    return {
-        get value() {
-            return _value;
-        },
-        set value(state) {
-            _value = state;
-        },
-        get() {
-            return untrack(() => this.value);
-        },
-        set(state) {
-            untrack(() => {
-                _value = state;
-            });
-        },
-        untrack(call) {
-            return untrack(() => call(_value));
-        },
-    };
-}
-export { ValueState };