@minutemailer/kit 0.1.0 → 0.1.2

package/package.json

@@ -1,39 +1,48 @@
 {
   "name": "@minutemailer/kit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Minutemailer UI Kit",
   "license": "MIT",
   "author": "Minutemailer",
   "type": "module",
   "exports": {
     "./utils": "./utils/index.js",
-    "./icons": "./icons/index.js"
+    "./icons": "./icons/index.js",
+    "./store": "./store/index.js"
   },
   "sideEffects": false,
   "scripts": {
-    "test": "vitest",
+    "test": "vitest run",
     "coverage": "vitest --run --coverage",
     "start": "storybook dev -p 6006",
-    "build": "tsc && node esbuild.config.js",
+    "build": "npm run icons:build && tsc && node esbuild.config.js",
     "build-storybook": "storybook build",
     "icons:build": "npx @svgr/cli --icon --typescript --replace-attr-values \"#3D3D3D=currentColor\" --out-dir src/icons resources/icons",
     "prepub": "rm -r dist && npm run build && cp package.json dist",
-    "pub": "npm run prepub && cd dist && npm publish --access public"
+    "pub": "npm run prepub && cd dist && npm publish --access public",
+    "docs": "npx typedoc src/utils --out docs --plugin typedoc-material-theme --themeColor '#00b869'"
   },
-  "dependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
   },
   "devDependencies": {
     "@storybook/addon-essentials": "^8.6.2",
     "@storybook/blocks": "^8.6.2",
+    "@storybook/manager-api": "^8.6.3",
     "@storybook/react": "^8.6.2",
     "@storybook/react-vite": "^8.6.2",
     "@storybook/test": "^8.6.2",
+    "@storybook/theming": "^8.6.3",
     "@svgr/cli": "^8.1.0",
+    "@testing-library/react": "^16.2.0",
     "@vitest/coverage-v8": "^3.0.7",
     "esbuild": "^0.25.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
     "storybook": "^8.6.2",
+    "typedoc": "^0.27.9",
+    "typedoc-material-theme": "^1.3.0",
     "vitest": "^3.0.7"
   }
 }

package/state/index.d.ts

@@ -0,0 +1,22 @@
+interface StateMachine<TContext> {
+    subscribe: (listener: StateChange<TContext>) => () => void;
+    destroy: () => void;
+    action: (action: string, input?: any) => void;
+    can: (action: string) => boolean;
+    useCurrentState: () => string;
+    useCurrentContext: <TSelected = any>(selector: (context: TContext) => TSelected) => TSelected;
+    getContext: () => TContext;
+}
+interface Transitions {
+    [state: string]: {
+        on: {
+            [action: string]: string;
+        };
+    };
+}
+interface Actions {
+    [action: string]: (context: any, input?: any) => any;
+}
+type StateChange<TContext> = (state: string, previousState: string, context: TContext) => void;
+export declare function createMachine<TContext = any>(transitions: Transitions, actions: Actions, initialContext: TContext, initialState?: string): StateMachine<TContext>;
+export {};

package/state/index.js

@@ -0,0 +1,53 @@
+import { useEffect, useState } from 'react';
+export function createMachine(transitions, actions, initialContext, initialState = 'IDLE') {
+    const listeners = new Set();
+    let state = initialState;
+    let context = initialContext;
+    return {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        destroy() {
+            listeners.clear();
+            state = initialState;
+            context = initialContext;
+        },
+        action(action, input) {
+            const transition = transitions[state];
+            const nextState = transition.on[action];
+            if (!nextState) {
+                console.warn('Invalid transition', state, action);
+                return;
+            }
+            console.log(`Machine transition: ${state} -> ${nextState} (${action}, ${input})`);
+            const previousState = state;
+            if (actions[action]) {
+                context = actions[action].call(this, context, input) || context;
+            }
+            state = nextState;
+            listeners.forEach((listener) => listener(state, previousState, context));
+        },
+        can(action) {
+            const transition = transitions[state];
+            return !!transition.on[action];
+        },
+        useCurrentState() {
+            const [currentState, setCurrentState] = useState(state);
+            useEffect(() => {
+                return this.subscribe(() => setCurrentState(state));
+            }, []);
+            return currentState;
+        },
+        useCurrentContext(selector) {
+            const [currentContext, setCurrentContext] = useState(() => selector(context));
+            useEffect(() => {
+                return this.subscribe(() => setCurrentContext(selector(context)));
+            }, []);
+            return currentContext;
+        },
+        getContext() {
+            return context;
+        },
+    };
+}

package/state/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/state/index.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMachine } from './';
+// Mock timers for testing timeouts
+vi.useFakeTimers();
+describe('State Machine', () => {
+    // Test machine setup
+    const transitions = {
+        STATE1: { on: { NEXT: 'STATE2', RESET: 'STATE1' } },
+        STATE2: { on: { NEXT: 'STATE3', RESET: 'STATE1' } },
+        STATE3: { on: { NEXT: 'STATE1', RESET: 'STATE1' } },
+    };
+    const actions = {
+        NEXT: (context) => ({ count: context.count + 1 }),
+        RESET: () => ({ count: 0 }),
+    };
+    let machine;
+    beforeEach(() => {
+        machine = createMachine(transitions, actions, { count: 0 }, 'STATE1');
+    });
+    it('should initialize with the correct context', () => {
+        expect(machine.getContext()).toEqual({ count: 0 });
+    });
+    it('should transition to the next state when action is triggered', () => {
+        let currentState = 'STATE1';
+        // Subscribe to state changes
+        const unsubscribe = machine['subscribe']((newState) => {
+            currentState = newState;
+        });
+        machine.action('NEXT');
+        expect(currentState).toBe('STATE2');
+        unsubscribe();
+    });
+    it('should update context when action is triggered', () => {
+        let count = 0;
+        // Subscribe to context changes
+        const unsubscribe = machine['subscribe']((_, __, context) => {
+            count = context.count;
+        });
+        machine.action('NEXT');
+        expect(count).toBe(1);
+        unsubscribe();
+    });
+    it('should check if an action is valid for the current state', () => {
+        expect(machine.can('NEXT')).toBe(true);
+        expect(machine.can('INVALID')).toBe(false);
+        machine.action('NEXT');
+        // Now in STATE2
+        expect(machine.can('NEXT')).toBe(true);
+        expect(machine.can('RESET')).toBe(true);
+    });
+    it('should warn when invalid transition is attempted', () => {
+        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        machine.action('INVALID_ACTION');
+        expect(consoleSpy).toHaveBeenCalledWith('Invalid transition', 'STATE1', 'INVALID_ACTION');
+        consoleSpy.mockRestore();
+    });
+    it('should reset to initial state when destroy is called', () => {
+        let currentState = 'STATE1';
+        let currentContext = { count: 0 };
+        const unsubscribe = machine['subscribe']((newState, _, context) => {
+            currentState = newState;
+            currentContext = context;
+        });
+        machine.action('NEXT');
+        machine.action('NEXT');
+        // Now in STATE3 with count 2
+        expect(currentState).toBe('STATE3');
+        expect(currentContext.count).toBe(2);
+        machine.destroy();
+        // Direct check with getContext() since destroy clears subscribers
+        expect(machine.getContext()).toEqual({ count: 0 });
+        unsubscribe();
+    });
+    it('should log transitions to console', () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        machine.action('NEXT', 'test-input');
+        expect(consoleSpy).toHaveBeenCalledWith('Machine transition: STATE1 -> STATE2 (NEXT, test-input)');
+        consoleSpy.mockRestore();
+    });
+    it('should notify subscribers when state changes', () => {
+        const mockListener = vi.fn();
+        const unsubscribe = machine['subscribe'](mockListener);
+        machine.action('NEXT');
+        expect(mockListener).toHaveBeenCalledWith('STATE2', 'STATE1', { count: 1 });
+        // Test unsubscribe
+        unsubscribe();
+        machine.action('NEXT');
+        // Should have been called only once despite two actions
+        expect(mockListener).toHaveBeenCalledTimes(1);
+    });
+    it('should handle context updates with nested objects', () => {
+        const complexMachine = createMachine({ STATE1: { on: { UPDATE: 'STATE1' } } }, {
+            UPDATE: (ctx) => ({
+                ...ctx,
+                user: { ...ctx.user, age: ctx.user.age + 1 }
+            })
+        }, { user: { name: 'Test', age: 30 }, settings: { theme: 'dark' } }, 'STATE1');
+        let name = '';
+        let age = 0;
+        let theme = '';
+        const unsubscribe = complexMachine['subscribe']((_, __, context) => {
+            name = context.user.name;
+            age = context.user.age;
+            theme = context.settings.theme;
+        });
+        // Initial values from initialization
+        expect(complexMachine.getContext()).toEqual({
+            user: { name: 'Test', age: 30 },
+            settings: { theme: 'dark' }
+        });
+        complexMachine.action('UPDATE');
+        // Only age should change
+        expect(name).toBe('Test');
+        expect(age).toBe(31);
+        expect(theme).toBe('dark');
+        unsubscribe();
+    });
+});

package/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './store';
+export { useSelector } from './useSelector';

package/store/index.js

@@ -0,0 +1,6 @@
+export * from "./store";
+import { useSelector } from "./useSelector";
+export {
+  useSelector
+};
+//# sourceMappingURL=index.js.map

package/store/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/store/index.ts"],
+  "sourcesContent": ["// Reexport all from the store modules\nexport * from './store';\nexport { useSelector } from './useSelector';"],
+  "mappings": "AACA,cAAc;AACd,SAAS,mBAAmB;",
+  "names": []
+}

package/store/store.d.ts

@@ -0,0 +1,17 @@
+export type Action = {
+    type: string;
+    value?: any;
+};
+export interface Store<T> {
+    subscribe: (listener: StateChange<T>) => () => void;
+    reset: (persistent?: boolean) => void;
+    dispatch: (action: Action, cb?: () => void) => void;
+    select<S>(selector: (state: T) => S): S;
+    getState: () => T;
+}
+export type StateChange<T> = (state: T, prevState: T, action: Action) => void;
+export declare function getStore<T>(id: string): Store<T> | undefined;
+export declare function createStore<T>(id: string, initialState: T, reducer: (state: T, action: any) => T, shouldUpdate?: (prevState: T, state: T) => boolean, onStateChange?: StateChange<T>, persistent?: string | boolean): Store<T>;
+export declare function deleteStore(id: string, persistent?: boolean): void;
+export declare function resetAllStores(exceptions?: string[], persistent?: boolean): void;
+export declare function deleteAllStores(exceptions?: string[], persistent?: boolean): void;

package/store/store.js

@@ -0,0 +1,87 @@
+const stores = {};
+function loadPersistentState(id, key) {
+    try {
+        return JSON.parse(localStorage.getItem(key) || '');
+    }
+    catch (error) {
+        console.error(`Failed to load persistent state for ${id}`, error);
+    }
+    return null;
+}
+function savePersistentState(id, key, state) {
+    try {
+        localStorage.setItem(key, JSON.stringify(state));
+    }
+    catch (error) {
+        console.error(`Failed to save persistent state for ${id}`, error);
+    }
+}
+export function getStore(id) {
+    if (!stores[id]) {
+        console.warn(`Store ${id} does not exist`, stores);
+    }
+    return stores[id];
+}
+export function createStore(id, initialState, reducer, shouldUpdate = () => true, onStateChange = () => { }, persistent = false) {
+    if (stores[id]) {
+        return stores[id];
+    }
+    const listeners = new Set();
+    let state = initialState;
+    if (persistent) {
+        const persistentState = loadPersistentState(id, `${persistent}.${id}`);
+        if (persistentState) {
+            state = persistentState;
+        }
+    }
+    stores[id] = {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        reset(persistent = false) {
+            listeners.clear();
+            state = initialState;
+            if (persistent) {
+                localStorage.removeItem(`${persistent}.${id}`);
+            }
+        },
+        dispatch(action, cb = () => { }) {
+            const prevState = state;
+            state = reducer(state, action);
+            if (persistent) {
+                savePersistentState(id, `${persistent}.${id}`, state);
+            }
+            if (shouldUpdate(prevState, state)) {
+                listeners.forEach((listener) => listener(state, prevState, action));
+                onStateChange(state, prevState, action);
+                cb(state, prevState, action);
+            }
+        },
+        select(selector) {
+            return selector(state);
+        },
+        getState() {
+            return state;
+        },
+    };
+    return stores[id];
+}
+export function deleteStore(id, persistent = false) {
+    if (persistent) {
+        localStorage.removeItem(`${persistent}.${id}`);
+    }
+    delete stores[id];
+}
+export function resetAllStores(exceptions = [], persistent = false) {
+    Object.keys(stores)
+        .filter((id) => !exceptions.includes(id))
+        .forEach((id) => stores[id].reset(persistent));
+}
+export function deleteAllStores(exceptions = [], persistent = false) {
+    Object.keys(stores)
+        .filter((id) => !exceptions.includes(id))
+        .forEach((id) => deleteStore(id, persistent));
+}

package/store/store.test.d.ts

@@ -0,0 +1,12 @@
+import { Store } from './store';
+interface TestStore {
+    todos: Array<{
+        id: string;
+        text: string;
+        completed: boolean;
+    }>;
+    completed: number;
+    total: number;
+}
+export declare function createStoreInstance(): Store<TestStore>;
+export {};

package/store/store.test.js

@@ -0,0 +1,51 @@
+import { assert, assertType, test } from 'vitest';
+import { createStore } from './store';
+const initialState = {
+    todos: [],
+    completed: 0,
+    total: 0,
+};
+const uniqueId = () => Math.random().toString(36).substring(2, 15);
+const reducer = (state, action) => {
+    if (action.type === 'ADD_TODO') {
+        return {
+            ...state,
+            todos: [
+                ...state.todos,
+                { id: uniqueId(), text: action.value, completed: false },
+            ],
+            total: state.total + 1,
+        };
+    }
+    if (action.type === 'COMPLETE_TODO') {
+        return {
+            ...state,
+            todos: state.todos.map((todo) => todo.id === action.value ? { ...todo, completed: true } : todo),
+            completed: state.completed + 1,
+        };
+    }
+    if (action.type === 'UNCOMPLETE_TODO') {
+        return {
+            ...state,
+            todos: state.todos.map((todo) => todo.id === action.value ? { ...todo, completed: false } : todo),
+            completed: state.completed - 1,
+        };
+    }
+    return state;
+};
+export function createStoreInstance() {
+    return createStore('todos', initialState, reducer, () => true, () => { });
+}
+test('createStore returns store', () => {
+    const store = createStoreInstance();
+    assertType(store);
+});
+test('store.getState returns state', () => {
+    const store = createStoreInstance();
+    assert.equal(store.getState(), initialState);
+});
+test('store.select returns state', () => {
+    const store = createStoreInstance();
+    const scope = store.select(({ total }) => total);
+    assert.equal(scope, initialState.total);
+});

package/store/useSelector.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "@/store";
+export declare function useSelector<T, S>(store: Store<T>, selector: (state: T) => S): S;

package/store/useSelector.js

@@ -0,0 +1,8 @@
+import { useEffect, useState } from "react";
+export function useSelector(store, selector) {
+    const [selectedState, setSelectedState] = useState(() => store.select(selector));
+    useEffect(() => {
+        return store.subscribe(() => setSelectedState(store.select(selector)));
+    }, []);
+    return selectedState;
+}

package/stories/Todo.d.ts

@@ -0,0 +1 @@
+export default function Todo(): import("react/jsx-runtime").JSX.Element;

package/stories/Todo.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createStore, useSelector } from "@/store";
+import { useState } from "react";
+const initialState = {
+    todos: [],
+    completed: 0,
+    total: 0,
+};
+const uniqueId = () => Math.random().toString(36).substring(2, 15);
+const reducer = (state, action) => {
+    if (action.type === 'ADD_TODO') {
+        return {
+            ...state,
+            todos: [
+                ...state.todos,
+                { id: uniqueId(), text: action.value, completed: false },
+            ],
+            total: state.total + 1,
+        };
+    }
+    if (action.type === 'COMPLETE_TODO') {
+        return {
+            ...state,
+            todos: state.todos.map((todo) => todo.id === action.value ? { ...todo, completed: true } : todo),
+            completed: state.completed + 1,
+        };
+    }
+    if (action.type === 'UNCOMPLETE_TODO') {
+        return {
+            ...state,
+            todos: state.todos.map((todo) => todo.id === action.value ? { ...todo, completed: false } : todo),
+            completed: state.completed - 1,
+        };
+    }
+    return state;
+};
+const store = createStore('todos', initialState, reducer, () => true, () => {
+}, 'todos');
+function Todos() {
+    const todos = useSelector(store, (state) => state.todos);
+    return (_jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: '1rem' }, children: todos.map((todo) => (_jsx("div", { style: { display: 'flex', alignItems: 'center', gap: '1rem' }, children: _jsxs("div", { className: "flex items-center space-x-3", children: [_jsx("button", { type: "button", role: "checkbox", "aria-checked": todo.completed, "data-state": todo.completed ? 'checked' : 'unchecked', value: "on", className: "peer size-5 shrink-0 rounded-sm border border-input ring-offset-background focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground data-[state=checked]:border-accent-foreground", id: "remember", tabIndex: 3, onClick: () => store.dispatch({
+                            type: !todo.completed
+                                ? 'COMPLETE_TODO'
+                                : 'UNCOMPLETE_TODO',
+                            value: todo.id,
+                        }), children: todo.completed && (_jsx("span", { "data-state": "checked", className: "flex items-center justify-center text-current", style: { pointerEvents: 'none' }, children: _jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", className: "lucide lucide-check size-3.5 stroke-[3]", children: _jsx("path", { d: "M20 6 9 17l-5-5" }) }) })) }), _jsx("input", { "aria-hidden": "true", tabIndex: -1, type: "checkbox", value: "on", style: {
+                            transform: 'translateX(-100%)',
+                            position: 'absolute',
+                            pointerEvents: 'none',
+                            opacity: 0,
+                            margin: 0,
+                            width: '20px', height: '20px'
+                        } }), _jsx("label", { className: "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", htmlFor: "remember", children: todo.text })] }) }, todo.id))) }));
+}
+function Status() {
+    const total = useSelector(store, (state) => state.total);
+    const completed = useSelector(store, (state) => state.completed);
+    return _jsx("p", { className: "mt-4 text-sm text-muted-foreground", children: `${completed} / ${total} todos completed` });
+}
+function Form() {
+    const [value, setValue] = useState('');
+    function onSubmit(e) {
+        e.preventDefault();
+        store.dispatch({ type: 'ADD_TODO', value: value });
+        setValue('');
+    }
+    return (_jsxs("form", { onSubmit: onSubmit, className: "flex gap-2 mb-6", children: [_jsx("input", { className: "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm", placeholder: "Add a new todo", value: value, onChange: (e) => setValue(e.target.value) }), _jsx("button", { className: "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0 h-10 px-4 py-2 bg-black/80 hover:bg-black/70 text-white backdrop-blur-xl", type: "submit", children: "Add" })] }));
+}
+export default function Todo() {
+    return (_jsx("div", { children: _jsxs("div", { className: "max-w-md mx-auto p-6 bg-white rounded-lg border", children: [_jsx("h1", { className: "text-2xl font-bold text-center mb-6 sb-unstyled", children: "My Todo List" }), _jsx(Form, {}), _jsx(Todos, {}), _jsx(Status, {})] }) }));
+}

package/stories/TrafficLights.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const SimpleTrafficLight: React.FC;
+export default SimpleTrafficLight;

package/stories/TrafficLights.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { createMachine } from '@/state';
+// Simple traffic light demo with minimal code
+const SimpleTrafficLight = () => {
+    // Define our states, transitions and actions
+    const transitions = {
+        RED: { on: { NEXT: 'GREEN' } },
+        GREEN: { on: { NEXT: 'YELLOW' } },
+        YELLOW: { on: { NEXT: 'RED' } }
+    };
+    const actions = {
+        NEXT: (context) => ({
+            count: context.count + 1
+        })
+    };
+    // Create the machine with minimal context
+    const [machine] = useState(() => createMachine(transitions, actions, { count: 0 }, 'RED'));
+    // Get current state and count from the machine
+    const currentState = machine.useCurrentState();
+    const count = machine.useCurrentContext(ctx => ctx.count);
+    // Auto-transition every 1.5 seconds
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            machine.action('NEXT');
+        }, 1500);
+        return () => clearTimeout(timer);
+    }, [currentState, machine]);
+    // Color mapping
+    const colors = {
+        RED: 'bg-rose-500',
+        YELLOW: 'bg-amber-400',
+        GREEN: 'bg-emerald-500'
+    };
+    return (_jsxs("div", { className: "flex flex-col items-start p-4", children: [_jsx("div", { className: "bg-gray-800 p-3 rounded-lg mb-4 flex flex-col items-start gap-2", children: Object.entries(colors).map(([state, color]) => (_jsx("div", { className: `w-16 h-16 m-2 rounded-full ${currentState === state ? color : 'bg-gray-300'}` }, state))) }), _jsxs("div", { children: [_jsxs("p", { children: ["Current: ", _jsx("strong", { children: currentState })] }), _jsxs("p", { children: ["Cycles: ", count] }), _jsx("button", { onClick: () => machine.action('NEXT'), className: "mt-2 bg-blue-500 text-white px-4 py-2 rounded", children: "Next State" })] })] }));
+};
+export default SimpleTrafficLight;

package/utils/choice/index.d.ts

@@ -1 +1 @@
-export default function choice(string: any, value?: null): any;
+export default function choice(string: string, value?: number | null): string;

package/utils/choice/index.js

@@ -14,7 +14,8 @@ export default function choice(string, value = null) {
             const [start, end] = bracketMatch[1]
                 .split(',')
                 .map((item) => (item === 'Inf' ? item : parseInt(item, 10)));
-            if (value >= start &&
+            if (typeof start === 'number' &&
+                value >= start &&
                 (end === 'Inf' || value < end || end === undefined)) {
                 foundValue = option.replace(brackets, '').trim();
             }

package/utils/choice/index.test.js

@@ -1,5 +1,5 @@
 import { assert, test } from 'vitest';
-import choice from './index.js';
+import choice from './index';
 test('No processing if no value is given', () => {
     assert.equal(choice('foo'), 'foo');
     assert.equal(choice('foo|bar'), 'foo|bar');

package/utils/index.d.ts

@@ -2,5 +2,5 @@ export { default as strToDate } from './strToDate';
 export { default as zeroPad } from './zeroPad';
 export { default as replacePlaceholders } from './replacePlaceholders';
 export { default as choice } from './choice';
-export { default as capitalize } from './capitalize/index.js';
+export { default as capitalize } from './capitalize';
 export { default as objToQuery } from './objToQuery';

package/utils/index.js

@@ -2,7 +2,7 @@ import { default as default2 } from "./strToDate";
 import { default as default3 } from "./zeroPad";
 import { default as default4 } from "./replacePlaceholders";
 import { default as default5 } from "./choice";
-import { default as default6 } from "./capitalize/index.js";
+import { default as default6 } from "./capitalize";
 import { default as default7 } from "./objToQuery";
 export {
   default6 as capitalize,

package/utils/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/index.ts"],
-  "sourcesContent": ["export { default as strToDate } from './strToDate';\nexport { default as zeroPad } from './zeroPad';\nexport { default as replacePlaceholders } from './replacePlaceholders';\nexport { default as choice } from './choice';\nexport { default as capitalize } from './capitalize/index.js';\nexport { default as objToQuery } from './objToQuery';\n"],
+  "sourcesContent": ["export { default as strToDate } from './strToDate';\nexport { default as zeroPad } from './zeroPad';\nexport { default as replacePlaceholders } from './replacePlaceholders';\nexport { default as choice } from './choice';\nexport { default as capitalize } from './capitalize';\nexport { default as objToQuery } from './objToQuery';\n"],
   "mappings": "AAAA,SAAoB,WAAXA,gBAA4B;AACrC,SAAoB,WAAXA,gBAA0B;AACnC,SAAoB,WAAXA,gBAAsC;AAC/C,SAAoB,WAAXA,gBAAyB;AAClC,SAAoB,WAAXA,gBAA6B;AACtC,SAAoB,WAAXA,gBAA6B;",
   "names": ["default"]
 }

package/utils/objToQuery/index.d.ts

@@ -1 +1 @@
-export default function objToQuery(obj: any, exclude?: any[]): any;
+export default function objToQuery(obj: Record<string, any>, exclude?: string[]): string;

package/utils/objToQuery/index.test.js

@@ -1,5 +1,5 @@
 import { assert, test } from 'vitest';
-import objToQuery from './index.js';
+import objToQuery from './index';
 test('Returns string', () => {
     assert.isString(objToQuery({}));
 });

package/utils/replacePlaceholders/index.d.ts

@@ -1 +1 @@
-export default function replacePlaceholders(string: any, placeholders?: {}): any;
+export default function replacePlaceholders(string: string, placeholders?: Record<string, any>): string;

package/utils/replacePlaceholders/index.test.js

@@ -1,5 +1,5 @@
 import { assert, test } from 'vitest';
-import replacePlaceholders from './index.js';
+import replacePlaceholders from './index';
 test('Returns string', () => {
     assert.isString(replacePlaceholders('foo', {}));
 });

package/utils/strToDate/index.d.ts

@@ -1 +1 @@
-export default function strToDate(str: any): Date | null;
+export default function strToDate(str?: any): Date | null;

package/utils/strToDate/index.test.js

@@ -1,5 +1,5 @@
 import { assert, test } from 'vitest';
-import strToDate from './index.js';
+import strToDate from './index';
 test('strToDate returns Date for Date', () => {
     assert.instanceOf(strToDate(new Date()), Date);
     const date = new Date();
@@ -24,12 +24,18 @@ test('strToDate returns null for invalid input', () => {
 });
 test('strToDate returns correct date', () => {
     const date = strToDate('2020-01-01');
+    if (!date) {
+        throw new Error('Date is null');
+    }
     assert.equal(date.getFullYear(), 2020);
     assert.equal(date.getMonth(), 0);
     assert.equal(date.getDate(), 1);
 });
 test('strToDate returns correct date and time', () => {
     const date = strToDate('2020-01-01 20:00:00');
+    if (!date) {
+        throw new Error('Date is null');
+    }
     assert.equal(date.getFullYear(), 2020);
     assert.equal(date.getMonth(), 0);
     assert.equal(date.getDate(), 1);

package/utils/zeroPad/index.test.js

@@ -1,5 +1,5 @@
 import { assert, test } from 'vitest';
-import zeroPad from './index.js';
+import zeroPad from './index';
 test('zeroPad returns string', () => {
     assert.isString(zeroPad(1));
 });