@ngstato/core 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# @ngstato/core
+
+State management framework-agnostic — Signals-first, sans RxJS obligatoire.
+
+## Installation
+```bash
+npm install @ngstato/core
+```
+
+## Usage
+```ts
+import { createStore, http } from '@ngstato/core'
+
+const store = createStore({
+  users:     [] as User[],
+  isLoading: false,
+
+  actions: {
+    async loadUsers(state) {
+      state.isLoading = true
+      state.users     = await http.get('/users')
+      state.isLoading = false
+    }
+  },
+
+  computed: {
+    total: (state) => state.users.length
+  }
+})
+
+await store.loadUsers()
+console.log(store.users)   // User[]
+console.log(store.total)   // number
+```
+
+## Helpers
+
+| Helper | Description |
+|--------|-------------|
+| `abortable()` | Annule la requête précédente si l'action est rappelée |
+| `debounced()` | Debounce sans RxJS |
+| `throttled()` | Throttle sans RxJS |
+| `retryable()` | Retry avec backoff fixe ou exponentiel |
+| `fromStream()` | Realtime — WebSocket, Firebase, Supabase |
+| `optimistic()` | Optimistic update + rollback automatique |
+
+## Documentation
+
+Voir [github.com/becher/ngstato](https://github.com/becher/ngstato)

package/dist/index.d.mts

@@ -0,0 +1,127 @@
+type StateSlice<T> = Omit<T, 'actions' | 'computed' | 'hooks'>;
+type Action<S> = (state: S, ...args: any[]) => void | Promise<void> | (() => void);
+type ActionsMap<S> = Record<string, Action<S>>;
+type ComputedFn<S> = (state: S) => unknown;
+interface StatoHooks<S> {
+    onInit?: (store: S) => void | Promise<void>;
+    onDestroy?: (store: S) => void | Promise<void>;
+    onAction?: (name: string, args: unknown[]) => void;
+    onActionDone?: (name: string, duration: number) => void;
+    onError?: (error: Error, actionName: string) => void;
+    onStateChange?: (prev: S, next: S) => void;
+}
+interface StatoStoreConfig<S extends object> {
+    actions?: ActionsMap<StateSlice<S>>;
+    computed?: Record<string, ComputedFn<StateSlice<S>> | unknown[]>;
+    hooks?: StatoHooks<any>;
+    [key: string]: unknown;
+}
+type StatoStoreInstance<S extends object> = {
+    readonly [K in keyof StateSlice<S>]: StateSlice<S>[K];
+} & {
+    [K in keyof S as S[K] extends Function ? K : never]: S[K] extends (state: any, ...args: infer A) => infer R ? (...args: A) => R : never;
+};
+interface StatoConfig {
+    baseUrl?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    auth?: () => string | null | undefined;
+}
+declare class StatoHttpError extends Error {
+    status: number;
+    body: string;
+    constructor(status: number, body: string);
+}
+
+declare function createStore<S extends object>(config: S & StatoStoreConfig<S>): any;
+
+interface RequestOptions {
+    params?: Record<string, string | number | boolean>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+declare class StatoHttp {
+    private _config;
+    constructor(config?: StatoConfig);
+    get<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    private _request;
+    private _buildUrl;
+}
+declare function createHttp(config?: StatoConfig): StatoHttp;
+declare function configureHttp(config: StatoConfig): void;
+declare const http: {
+    get: <T>(url: string, options?: RequestOptions) => Promise<T>;
+    post: <T>(url: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    put: <T>(url: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    patch: <T>(url: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    delete: <T>(url: string, options?: RequestOptions) => Promise<T>;
+};
+
+interface AbortableOptions {
+    signal: AbortSignal;
+}
+declare function abortable<S, A extends unknown[]>(fn: (state: S, ...args: [...A, AbortableOptions]) => Promise<void>): (state: S, ...args: A) => Promise<void>;
+
+declare function debounced<S, A extends unknown[]>(fn: (state: S, ...args: A) => void | Promise<void>, ms?: number): (state: S, ...args: A) => Promise<void>;
+
+declare function throttled<S, A extends unknown[]>(fn: (state: S, ...args: A) => void | Promise<void>, ms?: number): (state: S, ...args: A) => Promise<void>;
+
+interface RetryOptions {
+    attempts: number;
+    backoff: 'fixed' | 'exponential';
+    delay?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+declare function retryable<S, A extends unknown[]>(fn: (state: S, ...args: A) => Promise<void>, options?: RetryOptions): (state: S, ...args: A) => Promise<void>;
+
+interface StatoObservable<T> {
+    subscribe(observer: {
+        next?: (value: T) => void;
+        error?: (error: unknown) => void;
+        complete?: () => void;
+    }): {
+        unsubscribe(): void;
+    };
+}
+interface StreamOptions {
+    onComplete?: () => void;
+    onError?: (error: unknown) => void;
+}
+declare function fromStream<S, T>(setupFn: (state: S) => StatoObservable<T>, updateFn: (state: S, value: T) => void, options?: StreamOptions): (state: S) => (() => void);
+
+declare function optimistic<S, A extends unknown[]>(immediate: (state: S, ...args: A) => void, confirm: (state: S, ...args: A) => Promise<void>): (state: S, ...args: A) => Promise<void>;
+
+interface ActionLog {
+    id: number;
+    name: string;
+    args: unknown[];
+    duration: number;
+    status: 'success' | 'error';
+    error?: string;
+    prevState: unknown;
+    nextState: unknown;
+    at: string;
+}
+interface DevToolsState {
+    logs: ActionLog[];
+    isOpen: boolean;
+    maxLogs: number;
+}
+interface DevToolsInstance {
+    state: DevToolsState;
+    logAction: (log: Omit<ActionLog, 'id' | 'at'>) => void;
+    clear: () => void;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    subscribe: (cb: (state: DevToolsState) => void) => () => void;
+}
+declare function createDevTools(maxLogs?: number): DevToolsInstance;
+declare const devTools: DevToolsInstance;
+declare function connectDevTools(store: any, storeName: string): void;
+
+export { type ActionLog, type DevToolsInstance, type DevToolsState, type RequestOptions, type StatoConfig, type StatoHooks, StatoHttp, StatoHttpError, type StatoStoreConfig, type StatoStoreInstance, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled };

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+type StateSlice<T> = Omit<T, 'actions' | 'computed' | 'hooks'>;
+type Action<S> = (state: S, ...args: any[]) => void | Promise<void> | (() => void);
+type ActionsMap<S> = Record<string, Action<S>>;
+type ComputedFn<S> = (state: S) => unknown;
+interface StatoHooks<S> {
+    onInit?: (store: S) => void | Promise<void>;
+    onDestroy?: (store: S) => void | Promise<void>;
+    onAction?: (name: string, args: unknown[]) => void;
+    onActionDone?: (name: string, duration: number) => void;
+    onError?: (error: Error, actionName: string) => void;
+    onStateChange?: (prev: S, next: S) => void;
+}
+interface StatoStoreConfig<S extends object> {
+    actions?: ActionsMap<StateSlice<S>>;
+    computed?: Record<string, ComputedFn<StateSlice<S>> | unknown[]>;
+    hooks?: StatoHooks<any>;
+    [key: string]: unknown;
+}
+type StatoStoreInstance<S extends object> = {
+    readonly [K in keyof StateSlice<S>]: StateSlice<S>[K];
+} & {
+    [K in keyof S as S[K] extends Function ? K : never]: S[K] extends (state: any, ...args: infer A) => infer R ? (...args: A) => R : never;
+};
+interface StatoConfig {
+    baseUrl?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    auth?: () => string | null | undefined;
+}
+declare class StatoHttpError extends Error {
+    status: number;
+    body: string;
+    constructor(status: number, body: string);
+}
+
+declare function createStore<S extends object>(config: S & StatoStoreConfig<S>): any;
+
+interface RequestOptions {
+    params?: Record<string, string | number | boolean>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+declare class StatoHttp {
+    private _config;
+    constructor(config?: StatoConfig);
+    get<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    private _request;
+    private _buildUrl;
+}
+declare function createHttp(config?: StatoConfig): StatoHttp;
+declare function configureHttp(config: StatoConfig): void;
+declare const http: {
+    get: <T>(url: string, options?: RequestOptions) => Promise<T>;
+    post: <T>(url: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    put: <T>(url: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    patch: <T>(url: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    delete: <T>(url: string, options?: RequestOptions) => Promise<T>;
+};
+
+interface AbortableOptions {
+    signal: AbortSignal;
+}
+declare function abortable<S, A extends unknown[]>(fn: (state: S, ...args: [...A, AbortableOptions]) => Promise<void>): (state: S, ...args: A) => Promise<void>;
+
+declare function debounced<S, A extends unknown[]>(fn: (state: S, ...args: A) => void | Promise<void>, ms?: number): (state: S, ...args: A) => Promise<void>;
+
+declare function throttled<S, A extends unknown[]>(fn: (state: S, ...args: A) => void | Promise<void>, ms?: number): (state: S, ...args: A) => Promise<void>;
+
+interface RetryOptions {
+    attempts: number;
+    backoff: 'fixed' | 'exponential';
+    delay?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+declare function retryable<S, A extends unknown[]>(fn: (state: S, ...args: A) => Promise<void>, options?: RetryOptions): (state: S, ...args: A) => Promise<void>;
+
+interface StatoObservable<T> {
+    subscribe(observer: {
+        next?: (value: T) => void;
+        error?: (error: unknown) => void;
+        complete?: () => void;
+    }): {
+        unsubscribe(): void;
+    };
+}
+interface StreamOptions {
+    onComplete?: () => void;
+    onError?: (error: unknown) => void;
+}
+declare function fromStream<S, T>(setupFn: (state: S) => StatoObservable<T>, updateFn: (state: S, value: T) => void, options?: StreamOptions): (state: S) => (() => void);
+
+declare function optimistic<S, A extends unknown[]>(immediate: (state: S, ...args: A) => void, confirm: (state: S, ...args: A) => Promise<void>): (state: S, ...args: A) => Promise<void>;
+
+interface ActionLog {
+    id: number;
+    name: string;
+    args: unknown[];
+    duration: number;
+    status: 'success' | 'error';
+    error?: string;
+    prevState: unknown;
+    nextState: unknown;
+    at: string;
+}
+interface DevToolsState {
+    logs: ActionLog[];
+    isOpen: boolean;
+    maxLogs: number;
+}
+interface DevToolsInstance {
+    state: DevToolsState;
+    logAction: (log: Omit<ActionLog, 'id' | 'at'>) => void;
+    clear: () => void;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    subscribe: (cb: (state: DevToolsState) => void) => () => void;
+}
+declare function createDevTools(maxLogs?: number): DevToolsInstance;
+declare const devTools: DevToolsInstance;
+declare function connectDevTools(store: any, storeName: string): void;
+
+export { type ActionLog, type DevToolsInstance, type DevToolsState, type RequestOptions, type StatoConfig, type StatoHooks, StatoHttp, StatoHttpError, type StatoStoreConfig, type StatoStoreInstance, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled };