@kirill.konshin/utils 0.0.19 → 0.0.21

package/src/bootstrap/toaster.stories.tsx

@@ -1,32 +0,0 @@
-import type { Meta, StoryObj } from '@storybook/react';
-import { fn } from '@storybook/test';
-
-import { Toaster } from './toaster';
-
-// More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta: Meta<typeof Toaster> = {
-    title: 'Bootstrap / Toaster',
-    component: Toaster,
-    parameters: {
-        layout: 'centered',
-    },
-    tags: ['autodocs'],
-    argTypes: {},
-    args: { onClick: fn() },
-};
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {
-    args: {
-        toast: 'Hello, World!',
-    },
-};
-
-export const Object: Story = {
-    args: {
-        toast: { message: 'Toast', variant: 'dark' },
-    },
-};

package/src/bootstrap/toaster.tsx

@@ -1,40 +0,0 @@
-'use client';
-
-import React, { useState, FC } from 'react';
-import { Toast, ToastProps } from 'react-bootstrap';
-// import { useToaster } from '../redux/toasterSlice';
-
-export type ToasterProps = {
-    toast: string | { message: string; title?: string; variant?: 'dark' | 'success' | 'danger' };
-} & ToastProps;
-
-export const Toaster: FC<ToasterProps> = function Toaster({ toast }) {
-    //const { toast, setToast } = useToaster();
-    const [dismissed, setDismissed] = useState(false);
-
-    const msg = typeof toast === 'string' ? toast : toast?.message;
-    // const title = typeof toast === 'string' ? 'Notification' : toast?.title;
-    const variant = typeof toast === 'string' ? '' : toast?.variant;
-
-    return (
-        <Toast
-            onClose={() => setDismissed(true)}
-            show={!dismissed}
-            delay={10000}
-            autohide
-            bg={variant?.toLowerCase()}
-            className="position-fixed top-50 right-50 min-w-200px z-3"
-        >
-            <Toast.Header>
-                <strong className="me-auto">Notification</strong>
-            </Toast.Header>
-            <Toast.Body
-                className={
-                    ['dark', 'success', 'danger'].includes((variant as string)?.toLowerCase()) ? 'text-white' : ''
-                }
-            >
-                {msg}
-            </Toast.Body>
-        </Toast>
-    );
-};

package/src/bootstrap/useModal.stories.tsx

@@ -1,51 +0,0 @@
-import React, { FC } from 'react';
-import type { Meta, StoryObj } from '@storybook/react';
-import { useModal, UseModalProps } from './useModal';
-import { Button } from 'react-bootstrap';
-
-// More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta: Meta<FC<UseModalProps>> = {
-    title: 'Bootstrap / useModal',
-    parameters: {
-        layout: 'centered',
-    },
-    tags: ['autodocs'],
-    argTypes: {
-        children: { control: 'text' },
-        title: { control: 'text' },
-        cancelButton: { control: 'text' },
-        submitButton: { control: 'text' },
-        offcanvas: { control: 'check' },
-    },
-    args: {
-        children: 'Modal Content',
-        title: 'Modal Title',
-    },
-    render: function Demo(args) {
-        const { open, show, close, ModalDialog } = useModal();
-        return (
-            <>
-                <Button onClick={open}>Open Modal</Button>
-                <ModalDialog {...args} show={show}>
-                    {args.children}
-                    <Button onClick={close}>Close Modal</Button>
-                </ModalDialog>
-            </>
-        );
-    },
-    // args: { onSubmit: (e) => e.preventDefault() },
-};
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {
-    args: {},
-};
-
-export const Offcanvas: Story = {
-    args: {
-        offcanvas: true,
-    },
-};

package/src/bootstrap/useModal.tsx

@@ -1,93 +0,0 @@
-import React, { useCallback, useMemo, useState, JSX, FC, memo } from 'react';
-import { Button, Modal, ModalProps, Offcanvas, OffcanvasProps, Stack } from 'react-bootstrap';
-
-export type UseModalArgs = { onClose?: any; showOnMount?: boolean };
-
-export type UseModalProps = {
-    children?: any;
-    show?: boolean;
-    onSubmit?: (e: any) => void;
-    submitButton?: string | any;
-    cancelButton?: string | any;
-    offcanvas?: boolean;
-    title?: string | any;
-    containerProps?: ModalProps | OffcanvasProps;
-};
-
-export function useModal({ onClose, showOnMount }: UseModalArgs = {}): {
-    show: boolean | undefined;
-    close: () => void;
-    open: () => void;
-    ModalDialog: FC<ModalProps>;
-} {
-    const [show, setShow] = useState(showOnMount);
-
-    const close = useCallback((): void => {
-        setShow(false);
-        onClose?.();
-    }, [onClose]);
-
-    const open = useCallback((): void => setShow(true), []);
-
-    const defaultOnSubmit = useCallback(
-        (e: any) => {
-            e.preventDefault();
-            close();
-        },
-        [close],
-    );
-
-    const ModalDialog = useMemo(
-        () =>
-            memo(function ModalDialog({
-                children,
-                show,
-                onSubmit = defaultOnSubmit,
-                submitButton = 'Done',
-                cancelButton = 'Cancel',
-                offcanvas = false,
-                title = null as any,
-                containerProps = {},
-            }: ModalProps) {
-                const Container = offcanvas ? Offcanvas : Modal;
-                const containerDefaultProps = offcanvas ? { style: { maxWidth: '85%' } } : {};
-                const Body = offcanvas ? Offcanvas.Body : Modal.Body;
-                const Header = offcanvas ? Offcanvas.Header : Modal.Header;
-                const Title = offcanvas ? Offcanvas.Title : Modal.Title;
-
-                return (
-                    <Container {...{ ...containerDefaultProps, ...containerProps }} show={show} onHide={close}>
-                        <form onSubmit={onSubmit}>
-                            {title && (
-                                <Header closeButton>
-                                    <Title>{title}</Title>
-                                </Header>
-                            )}
-
-                            <Body as={Stack} gap={3}>
-                                {show && children}
-                            </Body>
-
-                            {!offcanvas && (submitButton || cancelButton) && (
-                                <Modal.Footer>
-                                    {cancelButton && (
-                                        <Button variant="outline-secondary" onClick={close}>
-                                            {cancelButton}
-                                        </Button>
-                                    )}
-                                    {submitButton && (
-                                        <Button variant="secondary" type="submit">
-                                            {submitButton}
-                                        </Button>
-                                    )}
-                                </Modal.Footer>
-                            )}
-                        </form>
-                    </Container>
-                );
-            }),
-        [close, defaultOnSubmit],
-    );
-
-    return { show, close, open, ModalDialog };
-}

package/src/bootstrap/useWrappedForm.ts

@@ -1,42 +0,0 @@
-import { useForm, FormState } from 'react-hook-form';
-import { useCallback } from 'react';
-
-export const isFormLoading = (formState: FormState<any>): boolean => formState.isLoading || formState.isSubmitting;
-
-export const useWrappedForm: typeof useForm = (options) => {
-    const form = useForm(options);
-
-    const handleSubmit: typeof form.handleSubmit = useCallback(
-        (onSubmit, onError) => {
-            const wrappedSubmit: typeof onSubmit = async (data) => {
-                try {
-                    await onSubmit(data);
-                } catch (e) {
-                    form.setError('root', { type: 'server', message: (e as Error).message });
-                    console.error('Error submitting form', e);
-                }
-            };
-            return form.handleSubmit(wrappedSubmit, onError);
-        },
-        [form],
-    );
-
-    return { ...form, handleSubmit };
-};
-
-/**
- * Issue #3: Submit event still propagates to parent when using portal
- * https://reactjs.org/docs/portals.html#event-bubbling-through-portals
- * Event bubbling goes through React DOM instead of HTML DOM
- * Portals don't have an effect on this one, we need to stop event propagation
- * This should be our default form handling method
- * https://codesandbox.io/s/react-hook-form-nested-portal-6x3fvy?file=/src/App.tsx:1905-2261
- * https://github.com/react-hook-form/react-hook-form/issues/1005#issuecomment-988380981
- */
-export const stopPropagation =
-    (callback: any) =>
-    (e: Event): void => {
-        e.stopPropagation();
-        e.preventDefault();
-        callback(e);
-    };

package/src/core/README.md

@@ -1,91 +0,0 @@
-# WRPC
-
-TODO
-
-- [ ] Add to readme https://stackoverflow.com/questions/77727664/how-to-get-returned-value-from-async-generator-when-using-for-await
-- [ ] Value passed to next are ignored https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator/next#sending_values_to_the_generator
-
-```mermaid
-sequenceDiagram
-    box Main
-    participant Code
-    participant Caller
-    end
-    box Worker
-    participant Worker
-    participant Resolver
-    end
-
-    %% autonumber
-
-    Code->>Caller: caller.generator(payload)
-
-    Caller-->>Code: iterator & promise
-
-    Code->>Code: Start main CONSUMER loop
-
-    Code->>Caller: iterator[Symbol]()
-
-    Caller->>Caller: Start replica GENERATOR loop
-
-    Code->>Caller: iterator.next()
-
-    Caller->>Worker: postMessage(payload)
-
-    Worker->>Resolver: resolver(payload)
-
-    Resolver-->>Worker: iterator
-
-    Worker->>Worker: Start replica CONSUMER loop
-
-    Worker->>Resolver: iterator[Symbol]()
-
-    Resolver->>Resolver: Start GENERATOR loop
-
-    rect rgb(232, 244, 248)
-
-        loop Synchronized iteration
-            Worker->>+Resolver: iterator.next(payload)
-
-            Resolver-->>-Worker: yield value
-
-            Worker-->>Caller: postMessage(value, done=false)
-
-            Note over Worker: Wait for ACK or ABORT
-
-            Caller-->>Code: yield value
-
-            Code->>Caller: iterator.next(nextPayload)
-
-            Caller->>Worker: postMessage(ack, nextPayload)
-        end
-
-    end
-
-    break Break or AbortSignal (maybe)
-        Code-->>Code: Loop exits
-        Code->>Caller: signal.abort()
-
-        Caller-->>Caller: Loop exits
-
-        Caller->>Worker: postMessage(abort)
-
-        Worker-->>Worker: Loop exits via Break
-
-        Resolver-->>Resolver: Loop exits
-    end
-
-    opt Occurs on Error
-        Resolver-->>Worker: throw Error
-
-        Worker-->>Caller: postMessage(error, done=true)
-
-        Caller-->>Code: throw Error
-    end
-
-    Resolver-->>Worker: return value
-
-    Worker-->>Caller: postMessage(value, done=true)
-
-    Caller-->>Code: return value
-```

package/src/core/cache.test.ts

@@ -1,121 +0,0 @@
-import { expect, describe, test, vi } from 'vitest';
-import { ANY, MaybePromise, memo, TransformerMap } from './cache';
-
-describe('memo', async () => {
-    test('simple', async () => {
-        const random = vi.fn(() => Math.random());
-        const memoized = memo(random);
-
-        const first = await memoized();
-        const second = await memoized();
-
-        expect(first.hit).toBeFalsy();
-        expect(second.hit).toBeTruthy();
-        expect(first.value).toBe(second.value);
-        expect(memoized.size()).toBe(1);
-
-        memoized.clear();
-        expect(memoized.size()).toBe(0);
-
-        const third = await memoized();
-        expect(third.hit).toBeFalsy();
-    });
-
-    test('with key', async () => {
-        const random = vi.fn((arg) => arg + Math.random().toString());
-        const memoized = memo(random);
-
-        const first = await memoized(1);
-        const second = await memoized(2);
-
-        expect(first.hit).toBeFalsy();
-        expect(second.hit).toBeFalsy();
-        expect(first.value).not.toBe(second.value);
-        expect(memoized.size()).toBe(2);
-
-        const first2 = await memoized(1);
-        const second2 = await memoized(2);
-
-        expect(first2.hit).toBeTruthy();
-        expect(first.value).toBe(first2.value);
-        expect(second2.hit).toBeTruthy();
-        expect(second.value).toBe(second2.value);
-
-        memoized.clear(1);
-        expect(memoized.size()).toBe(1);
-        memoized.clear(ANY);
-        expect(memoized.size()).toBe(0);
-    });
-});
-
-describe('TransformerMap', async () => {
-    test('simple', async () => {
-        const dispose = vi.fn();
-
-        class Cache extends TransformerMap<number, any> {
-            write(key, value, oldValue) {
-                value.cached = true;
-                value.read = 0;
-                return value;
-            }
-            read(value, key) {
-                value.read++;
-                return value;
-            }
-            dispose(value, key) {
-                dispose(value, key);
-            }
-        }
-
-        const cache = new Cache('test');
-
-        const obj = { a: 1 };
-
-        const x1 = await cache.memo(1, obj);
-        expect(x1).toStrictEqual({ a: 1, cached: true, read: 0 });
-
-        const x2 = await cache.memo(1, obj);
-        expect(x2).toStrictEqual({ a: 1, cached: true, read: 1 });
-
-        const x3 = await cache.memo(1, { a: 2 });
-        expect(x3).toStrictEqual({ a: 2, cached: true, read: 0 });
-        expect(cache.size).toEqual(1);
-        expect(dispose).toBeCalledTimes(1);
-        expect(dispose).toBeCalledWith({ a: 1, cached: true, read: 1 }, 1);
-
-        const x4 = await cache.memo(2, { a: 20 });
-
-        expect(x4).toStrictEqual({ a: 20, cached: true, read: 0 });
-        expect(cache.size).toEqual(2);
-        expect(dispose).toBeCalledTimes(1);
-    });
-
-    test('key transform', async () => {
-        const dispose = vi.fn();
-
-        class Cache extends TransformerMap<number, any> {
-            write(key, value, oldValue) {
-                return { key, read: 0 };
-            }
-            read(value, key) {
-                value.read++;
-                return value;
-            }
-            dispose(value, key) {
-                dispose(value, key);
-            }
-        }
-
-        const cache = new Cache('test');
-
-        const x1 = await cache.memo(1);
-        expect(x1).toStrictEqual({ key: 1, read: 0 });
-
-        const x2 = await cache.memo(1);
-        expect(x2).toStrictEqual({ key: 1, read: 1 });
-
-        cache.clear();
-        expect(dispose).toBeCalledTimes(1);
-        expect(dispose).toBeCalledWith({ key: 1, read: 1 }, 1);
-    });
-});