@vanyamate/sec 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vanyamate/sec",
-    "version": "0.2.3",
+    "version": "0.2.4",
     "description": "SEC. Store, Effect, Combine. Tiny state manager",
     "scripts": {
         "build": "vite build",
@@ -16,6 +16,11 @@
             "require": "./dist/index.cjs"
         }
     },
+    "files": [
+        "dist",
+        "package.json",
+        "README.md"
+    ],
     "repository": {
         "type": "git",
         "url": "git+https://github.com/VanyaMate/sec.git"

package/src/combine/index.ts

@@ -1,55 +0,0 @@
-import {
-    enableCheck,
-    Store, StoreListener,
-} from '../store';
-import { Marker } from '../marker';
-
-
-export const combine = function <State, States extends Array<any>> (
-    stores: { [Index in keyof States]: Store<States[Index]> },
-    callback: (...stores: { [K in keyof States]: Store<States[K]> }) => State,
-    enabled: boolean = true,
-): Store<State> {
-    let combinedState: State                     = callback(...stores);
-    const listeners: Array<StoreListener<State>> = [];
-
-    stores.forEach((store) => {
-        store.subscribe(() => {
-            enableCheck(enabled, () => {
-                combinedState = callback(...stores);
-                listeners.forEach((listener) => listener(combinedState));
-            });
-        });
-    });
-
-    const storeApi: Store<State> = {
-        on: () => {
-            throw new Error(`Cannot call 'on' on combined store`);
-        },
-        get (): State {
-            return combinedState;
-        },
-        set () {
-            throw new Error(`Cannot call 'set' on combined store`);
-        },
-        subscribe (listener: StoreListener<State>) {
-            listeners.push(listener);
-            return () => {
-                const index = listeners.indexOf(listener);
-                if (~index) {
-                    listeners.splice(index, 1);
-                }
-            };
-        },
-        enableOn (marker: Marker<State>) {
-            marker.subscribe(() => enabled = false);
-            return storeApi;
-        },
-        disableOn (marker: Marker<State>) {
-            marker.subscribe(() => enabled = true);
-            return storeApi;
-        },
-    };
-
-    return storeApi;
-};

package/src/effect/index.ts

@@ -1,115 +0,0 @@
-export type EffectAction = (...args: Array<any>) => Promise<any>;
-export type EffectSuccessCallback<AsyncAction extends EffectAction> = (result: Awaited<ReturnType<AsyncAction>>, ...args: Parameters<AsyncAction>) => void;
-export type EffectErrorCallback<AsyncAction extends EffectAction> = (error: unknown, ...args: Parameters<AsyncAction>) => void;
-export type EffectBeforeCallback<AsyncAction extends EffectAction> = (...args: Parameters<AsyncAction>) => void;
-export type EffectFinallyCallback<AsyncAction extends EffectAction> = (...args: Parameters<AsyncAction>) => void;
-
-export type EffectSubscribePosition =
-    'beforeAll'
-    | 'afterAll'
-    | undefined;
-
-export type Effect<AsyncAction extends EffectAction> = {
-    (...args: Parameters<AsyncAction>): Promise<Awaited<ReturnType<AsyncAction>>>;
-    onSuccess: (callback: EffectSuccessCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
-    onError: (callback: EffectErrorCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
-    onBefore: (callback: EffectBeforeCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
-    onFinally: (callback: EffectFinallyCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
-}
-
-export type EffectCallbackList<Type> = {
-    beforeAll: Array<Type>;
-    afterAll: Array<Type>;
-    other: Array<Type>;
-}
-
-const getCallbacksList = function <Type> (): EffectCallbackList<Type> {
-    return {
-        afterAll : [],
-        beforeAll: [],
-        other    : [],
-    };
-};
-
-export const effect = function <Action extends EffectAction> (action: Action): Effect<Action> {
-    const beforeCallbacks: EffectCallbackList<EffectBeforeCallback<Action>>   = getCallbacksList<EffectBeforeCallback<Action>>();
-    const successCallbacks: EffectCallbackList<EffectSuccessCallback<Action>> = getCallbacksList<EffectSuccessCallback<Action>>();
-    const errorCallbacks: EffectCallbackList<EffectErrorCallback<Action>>     = getCallbacksList<EffectErrorCallback<Action>>();
-    const finallyCallbacks: EffectCallbackList<EffectFinallyCallback<Action>> = getCallbacksList<EffectFinallyCallback<Action>>();
-
-    const effectApi: Effect<Action> = async function (...args) {
-        beforeCallbacks.beforeAll.forEach((callback) => callback(...args));
-        beforeCallbacks.other.forEach((callback) => callback(...args));
-        beforeCallbacks.afterAll.forEach((callback) => callback(...args));
-
-        return action(...args)
-            .then((result: Awaited<ReturnType<Action>>) => {
-                successCallbacks.beforeAll.forEach((callback) => callback(result, ...args));
-                successCallbacks.other.forEach((callback) => callback(result, ...args));
-                successCallbacks.afterAll.forEach((callback) => callback(result, ...args));
-                return result;
-            })
-            .catch((error: unknown) => {
-                errorCallbacks.beforeAll.forEach((callback) => callback(error, ...args));
-                errorCallbacks.other.forEach((callback) => callback(error, ...args));
-                errorCallbacks.afterAll.forEach((callback) => callback(error, ...args));
-                throw error;
-            })
-            .finally(() => {
-                finallyCallbacks.beforeAll.forEach((callback) => callback(...args));
-                finallyCallbacks.other.forEach((callback) => callback(...args));
-                finallyCallbacks.afterAll.forEach((callback) => callback(...args));
-            });
-    } as Effect<Action>;
-
-    effectApi.onBefore  = (callback: EffectBeforeCallback<Action>, position?: EffectSubscribePosition) => {
-        switch (position) {
-            case 'beforeAll':
-                beforeCallbacks.beforeAll.push(callback);
-                break;
-            case 'afterAll':
-                beforeCallbacks.afterAll.push(callback);
-                break;
-            default:
-                beforeCallbacks.other.push(callback);
-        }
-    };
-    effectApi.onSuccess = (callback: EffectSuccessCallback<Action>, position?: EffectSubscribePosition) => {
-        switch (position) {
-            case 'beforeAll':
-                successCallbacks.beforeAll.push(callback);
-                break;
-            case 'afterAll':
-                successCallbacks.afterAll.push(callback);
-                break;
-            default:
-                successCallbacks.other.push(callback);
-        }
-    };
-    effectApi.onError   = (callback: EffectErrorCallback<Action>, position?: EffectSubscribePosition) => {
-        switch (position) {
-            case 'beforeAll':
-                errorCallbacks.beforeAll.push(callback);
-                break;
-            case 'afterAll':
-                errorCallbacks.afterAll.push(callback);
-                break;
-            default:
-                errorCallbacks.other.push(callback);
-        }
-    };
-    effectApi.onFinally = (callback: EffectFinallyCallback<Action>, position?: EffectSubscribePosition) => {
-        switch (position) {
-            case 'beforeAll':
-                finallyCallbacks.beforeAll.push(callback);
-                break;
-            case 'afterAll':
-                finallyCallbacks.afterAll.push(callback);
-                break;
-            default:
-                finallyCallbacks.other.push(callback);
-        }
-    };
-
-    return effectApi;
-};

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './store';
-export * from './effect';
-export * from './combine';
-export * from './marker';
-export * from './pending';
-export * from './to';

package/src/marker/index.ts

@@ -1,34 +0,0 @@
-import { EffectAction, Effect, EffectSubscribePosition } from '../effect';
-import { StoreHandlerMap } from '../store';
-
-
-export type MarkerListener = () => void;
-
-export type Marker<State> = {
-    on: <Action extends EffectAction>(event: keyof StoreHandlerMap<State, Action>, effect: Effect<Action>, position?: EffectSubscribePosition) => Marker<State>;
-    subscribe: (listener: MarkerListener) => void;
-}
-
-export const marker = function <State> (position?: EffectSubscribePosition): Marker<State> {
-    const listeners: Array<MarkerListener> = [];
-
-    const markerApi: Marker<State> = {
-        on       : (event, effect) => {
-            if (event === 'onBefore') {
-                effect.onBefore(() => listeners.forEach((listener) => listener()), position);
-            } else if (event === 'onSuccess') {
-                effect.onSuccess(() => listeners.forEach((listener) => listener()), position);
-            } else if (event === 'onError') {
-                effect.onError(() => listeners.forEach((listener) => listener()), position);
-            } else {
-                effect.onFinally(() => listeners.forEach((listener) => listener()), position);
-            }
-            return markerApi;
-        },
-        subscribe: (listener: MarkerListener) => {
-            listeners.push(listener);
-        },
-    };
-
-    return markerApi;
-};

package/src/marker/marker.test.ts

@@ -1,85 +0,0 @@
-import { beforeAll, describe, expect, test, vi } from 'vitest';
-import { marker } from './index';
-import { effect } from '../effect';
-import { store } from '../store';
-
-
-const createPostAction = async (id: number) => {
-    return new Promise<{ id: number }>((resolve) => {
-        setTimeout(() => {
-            resolve({ id });
-        }, 500);
-    });
-};
-const loginAction      = async () => {
-};
-const logoutAction     = async () => {
-};
-const loginEffect      = effect(loginAction);
-const logoutEffect     = effect(logoutAction);
-const createPostEffect = effect(createPostAction);
-const loginMarker      = marker('beforeAll').on('onSuccess', loginEffect);
-const logoutMarker     = marker('afterAll').on('onSuccess', logoutEffect);
-
-const postsStore = store<Array<{ id: number }>>([], true)
-    .enableOn(loginMarker)
-    .disableOn(logoutMarker)
-    .on(createPostEffect, 'onSuccess', (state, { result }) => state.concat(result));
-
-describe('marker', () => {
-    beforeAll(() => {
-        postsStore.set([]);
-    });
-
-    test('check with effect', async () => {
-        const mockFunction = vi.fn();
-        loginMarker.subscribe(mockFunction);
-        await loginEffect().finally(() => {
-            expect(mockFunction).toBeCalledTimes(1);
-        });
-        await loginEffect().finally(() => {
-            expect(mockFunction).toBeCalledTimes(2);
-        });
-    });
-
-    test('check with effect + store', () => {
-        createPostEffect(1)
-            .finally(() => {
-                expect(postsStore.get()).deep.eq([]);
-            });
-
-        loginEffect().finally(async () => {
-            await createPostEffect(2).finally(() => {
-                expect(postsStore.get()).deep.eq([ { id: 2 } ]);
-            });
-            createPostEffect(3)
-                .then(() => {
-                    expect(postsStore.get()).deep.eq([ { id: 2 } ]);
-                });
-            logoutEffect();
-        });
-    });
-
-    test('check queue', () => {
-        const queue: Array<number> = [];
-        const logoutEffect         = async function () {
-            return new Promise(resolve => setTimeout(resolve, 100));
-        };
-        const beforeLogout         = effect(logoutEffect);
-        const middleLogout         = effect(logoutEffect);
-        const afterLogout          = effect(logoutEffect);
-
-        store<Array<number>>([]).on(middleLogout, 'onSuccess', (state) => {
-            queue.push(2);
-            return state;
-        });
-
-        marker('afterAll').on('onSuccess', afterLogout).subscribe(() => queue.push(3));
-        marker('beforeAll').on('onSuccess', beforeLogout).subscribe(() => queue.push(1));
-
-        logoutEffect()
-            .finally(() => {
-                expect(queue).deep.eq([ 1, 2, 3 ]);
-            });
-    });
-});

package/src/pending/index.ts

@@ -1,13 +0,0 @@
-import { store } from '../store';
-import { to } from '../to';
-import { Effect } from '../effect';
-
-
-export const pending = function (effects: Array<Effect<any>>) {
-    const _store = store<boolean>(false);
-    effects.forEach((effect) => {
-        _store.on(effect, 'onBefore', to(true));
-        _store.on(effect, 'onFinally', to(false));
-    });
-    return _store;
-};

package/src/pending/pending.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { effect } from '../effect';
-import { pending } from './index';
-
-
-describe('pending', () => {
-    test('valid', async () => {
-        const getPostsAction = async function () {
-            return new Promise<void>((resolve) => setTimeout(resolve, 200));
-        };
-
-        const getPostsEffect = effect(getPostsAction);
-
-        const postsPending = pending([ getPostsEffect ]);
-
-        expect(postsPending.get()).equal(false);
-
-        getPostsEffect();
-        await new Promise(resolve => setTimeout(resolve, 100));
-        expect(postsPending.get()).equal(true);
-        await new Promise(resolve => setTimeout(resolve, 150));
-        expect(postsPending.get()).equal(false);
-    });
-});

package/src/store/index.ts

@@ -1,134 +0,0 @@
-import { EffectAction, Effect, effect } from '../effect';
-import { Marker } from '../marker';
-
-
-export type StoreOnBeforeHandler<State, Action extends EffectAction> = (state: State, data: {
-    args: Parameters<Action>
-}) => State;
-export type StoreOnSuccessHandler<State, Action extends EffectAction> = (state: State, data: {
-    args: Parameters<Action>
-    result: Awaited<ReturnType<Action>>;
-}) => State;
-export type StoreOnErrorHandler<State, Action extends EffectAction> = (state: State, data: {
-    args: Parameters<Action>
-    error: unknown;
-}) => State;
-export type StoreOnFinallyHandler<State, Action extends EffectAction> = (state: State, data: {
-    args: Parameters<Action>
-}) => State;
-
-export type StoreHandlerMap<State, Action extends EffectAction> = {
-    onBefore: StoreOnBeforeHandler<State, Action>;
-    onSuccess: StoreOnSuccessHandler<State, Action>;
-    onError: StoreOnErrorHandler<State, Action>;
-    onFinally: StoreOnFinallyHandler<State, Action>;
-};
-
-export type StoreEffectSubscribe<State> =
-    <
-        Action extends EffectAction,
-        Event extends keyof StoreHandlerMap<State, Action>
-    > (
-        effect: Effect<Action>,
-        event: Event,
-        handler: StoreHandlerMap<State, Action>[Event],
-    ) => Store<State>;
-
-export type StoreListener<State> = (state: State) => void;
-export type StoreMarkerSubscribe<State> = (marker: Marker<State>) => Store<State>;
-
-export type Store<State> = {
-    on: StoreEffectSubscribe<State>;
-    enableOn: StoreMarkerSubscribe<State>;
-    disableOn: StoreMarkerSubscribe<State>;
-    get: () => State;
-    set: (data: State) => void;
-    subscribe: (listener: StoreListener<State>) => () => void;
-}
-
-export const enableCheck = function (enabled: boolean, callback: () => void) {
-    if (enabled) {
-        callback();
-    }
-};
-
-export const store = function <State extends any> (state: State, enabled: boolean = true): Store<State> {
-    const listeners: Array<StoreListener<State>> = [];
-
-    const storeApi: Store<State> = {
-        on: <
-            Action extends EffectAction,
-            Event extends keyof StoreHandlerMap<State, Action>
-        > (effect: Effect<Action>, event: Event, handler: StoreHandlerMap<State, Action>[Event]) => {
-            if (event === 'onBefore') {
-                effect.onBefore((...args) =>
-                    enableCheck(
-                        enabled,
-                        () => storeApi.set(
-                            (handler as StoreOnBeforeHandler<State, Action>)(state, { args }),
-                        ),
-                    ),
-                );
-            } else if (event === 'onSuccess') {
-                effect.onSuccess((result, ...args) =>
-                    enableCheck(
-                        enabled,
-                        () => storeApi.set(
-                            (handler as StoreOnSuccessHandler<State, Action>)(state, {
-                                result, args,
-                            }),
-                        ),
-                    ),
-                );
-            } else if (event === 'onError') {
-                effect.onError((error, ...args) =>
-                    enableCheck(
-                        enabled,
-                        () => storeApi.set(
-                            (handler as StoreOnErrorHandler<State, Action>)(state, {
-                                error, args,
-                            }),
-                        ),
-                    ),
-                );
-            } else {
-                effect.onFinally((...args) =>
-                    enableCheck(
-                        enabled,
-                        () => storeApi.set(
-                            (handler as StoreOnFinallyHandler<State, Action>)(state, { args }),
-                        ),
-                    ),
-                );
-            }
-
-            return storeApi;
-        },
-        get (): State {
-            return state;
-        },
-        set (value: State) {
-            state = value;
-            listeners.forEach((listener) => listener(state));
-        },
-        subscribe (listener: StoreListener<State>) {
-            listeners.push(listener);
-            return () => {
-                const index = listeners.indexOf(listener);
-                if (~index) {
-                    listeners.splice(index, 1);
-                }
-            };
-        },
-        enableOn (marker: Marker<State>) {
-            marker.subscribe(() => enabled = true);
-            return storeApi;
-        },
-        disableOn (marker: Marker<State>) {
-            marker.subscribe(() => enabled = false);
-            return storeApi;
-        },
-    };
-
-    return storeApi;
-};

package/src/to/index.ts

@@ -1,3 +0,0 @@
-export const to = function <State> (state: State) {
-    return () => state;
-};

package/src/to/to.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { to } from './index';
-
-
-describe('to', () => {
-    test('valid', () => {
-        const arr: Array<number> = [];
-        const obj                = {};
-
-        expect(to(1)()).equal(1);
-        expect(to(arr)()).equal(arr);
-        expect(to(obj)()).equal(obj);
-    });
-
-    test('invalid', () => {
-        const arr: Array<number> = [];
-        const obj                = {};
-
-        expect(to(1)()).not.equal(2);
-        expect(to(arr)()).not.equal(obj);
-        expect(to(obj)()).not.equal(arr);
-    });
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "compilerOptions": {
-        "skipLibCheck": true,
-        "strict": true,
-        "moduleResolution": "node",
-        "outDir": "dist",
-        "declaration": true,
-        "declarationMap": true,
-        "lib": [
-            "ESNext",
-            "DOM"
-        ]
-    }
-}

package/vite.config.ts

@@ -1,23 +0,0 @@
-import { defineConfig } from 'vitest/config';
-import dtsPlugin from 'vite-plugin-dts';
-
-
-export default defineConfig({
-    plugins: [
-        dtsPlugin({
-            outDir     : 'dist',
-            entryRoot  : 'src',
-            rollupTypes: true,
-        }),
-    ],
-    build  : {
-        outDir     : './dist',
-        target     : 'esnext',
-        emptyOutDir: true,
-        lib        : {
-            entry   : './src/index.ts',
-            fileName: 'index',
-            formats : [ 'es', 'cjs' ],
-        },
-    },
-});