synstate 0.1.0

package/src/core/utils/utils.test.mts

@@ -0,0 +1,88 @@
+import { asSafeInt } from 'ts-data-forge';
+import { binarySearch, halfInt } from './utils.mjs';
+
+describe(halfInt, () => {
+  test('case: even number', () => {
+    expect(halfInt(asSafeInt(2))).toBe(1);
+  });
+
+  test('case: odd positive number', () => {
+    expect(halfInt(asSafeInt(3))).toBe(1);
+  });
+
+  test('case: odd negative number', () => {
+    expect(halfInt(asSafeInt(-3))).toBe(-1);
+  });
+});
+
+describe(binarySearch, () => {
+  test('empty array', () => {
+    expect(binarySearch([], 0)).toBe(0);
+  });
+
+  test('1 element array (1)', () => {
+    expect(binarySearch([1], 0)).toBe(0);
+  });
+
+  test('1 element array (2)', () => {
+    expect(binarySearch([-1], 0)).toBe(1);
+  });
+
+  test('2 element array (1)', () => {
+    expect(binarySearch([-1, 1], 0)).toBe(1);
+  });
+
+  test('2 element array (2)', () => {
+    expect(binarySearch([1, 2], 0)).toBe(0);
+  });
+
+  test('2 element array (3)', () => {
+    expect(binarySearch([-2, -1], 0)).toBe(2);
+  });
+
+  test('array with same value (1)', () => {
+    expect([0, 1]).toContain(binarySearch([0], 0));
+  });
+
+  test('array with same value (2)', () => {
+    expect([0, 1, 2]).toContain(binarySearch([0, 0], 0));
+  });
+
+  test('array with same value (3)', () => {
+    expect([0, 1, 2, 3]).toContain(binarySearch([0, 0, 0], 0));
+  });
+
+  test('complicated example 1', () => {
+    expect([2, 3]).toContain(binarySearch([1, 3, 4, 6, 7, 8], 4));
+  });
+
+  test('complicated example 2', () => {
+    expect([2, 3, 4]).toContain(binarySearch([1, 3, 4, 4, 6, 7, 8], 4));
+  });
+
+  test('complicated example 3', () => {
+    expect(binarySearch([1, 3, 4, 4, 6, 7, 8], 0)).toBe(0);
+  });
+
+  test('complicated example 4', () => {
+    expect([0, 1]).toContain(binarySearch([1, 3, 4, 4, 6, 7, 8], 1));
+  });
+
+  test('complicated example 5', () => {
+    expect([0, 1, 2, 3]).toContain(
+      binarySearch([1, 1, 1, 3, 4, 4, 6, 7, 8], 1),
+    );
+  });
+
+  test('complicated example 6', () => {
+    expect([5, 6]).toContain(binarySearch([1, 3, 4, 4, 6, 7, 8], 7));
+  });
+
+  test('complicated example 7', () => {
+    expect([6, 7]).toContain(binarySearch([1, 3, 4, 4, 6, 7, 8], 8));
+  });
+
+  test('complicated example 8', () => {
+    expect(binarySearch([1, 3, 4, 4, 6, 7, 8], 9)).toBe(7);
+  });
+});

package/src/entry-point.mts

@@ -0,0 +1 @@
+export * from './index.mjs';

package/src/globals.d.mts

@@ -0,0 +1,4 @@
+/// <reference types="ts-type-forge" />
+
+// Timer types for Node.js/Browser compatibility
+type TimerId = ReturnType<typeof setTimeout>;

package/src/index.mts

@@ -0,0 +1,2 @@
+export * from './core/index.mjs';
+export * from './utils/index.mjs';

package/src/utils/create-event-emitter.mts

@@ -0,0 +1,62 @@
+import { source, type Observable } from '../core/index.mjs';
+
+/**
+ * Creates an event emitter for void events (events without payload).
+ * Returns a tuple of [observable, emitter function].
+ *
+ * @returns A tuple containing the observable and the emitter function
+ *
+ * @example
+ * ```ts
+ * const [click$, emitClick] = createEventEmitter();
+ *
+ * click$.subscribe(() => {
+ *   console.log('Clicked!');
+ * });
+ *
+ * emitClick(); // logs: Clicked!
+ * ```
+ */
+export const createEventEmitter = (): readonly [
+  Observable<void>,
+  () => void,
+] => {
+  const src$ = source<undefined>();
+
+  const emitter = (): void => {
+    src$.next(undefined);
+  };
+
+  return [src$, emitter];
+};
+
+/**
+ * Creates an event emitter with typed payload.
+ * Returns a tuple of [observable, emitter function].
+ *
+ * @template A - The type of the event payload
+ * @returns A tuple containing the observable and the emitter function
+ *
+ * @example
+ * ```ts
+ * const [message$, emitMessage] = createValueEmitter<string>();
+ *
+ * message$.subscribe((msg) => {
+ *   console.log(msg);
+ * });
+ *
+ * emitMessage('Hello'); // logs: Hello
+ * ```
+ */
+export const createValueEmitter = <A,>(): readonly [
+  Observable<A>,
+  (value: A) => void,
+] => {
+  const src$ = source<A>();
+
+  const emitter = (value: A): void => {
+    src$.next(value);
+  };
+
+  return [src$, emitter];
+};

package/src/utils/create-reducer.mts

@@ -0,0 +1,55 @@
+import { source, type InitializedObservable } from '../core/index.mjs';
+
+/**
+ * Creates a reducer-based state management container following the Redux pattern.
+ * Actions are dispatched to update the state according to the reducer function.
+ *
+ * @template S - The type of the state
+ * @template A - The type of actions
+ * @param reducer - A pure function that takes current state and action, returns new state
+ * @param initialState - The initial value of the state
+ * @returns An object containing the state observable, dispatch function, and snapshot getter
+ *
+ * @example
+ * ```ts
+ * const [state, dispatch] = createReducer(
+ *   (s, action: Readonly<{ type: 'increment' } | { type: 'decrement' }>) => {
+ *     switch (action.type) {
+ *       case 'increment':
+ *         return s + 1;
+ *       case 'decrement':
+ *         return s - 1;
+ *     }
+ *   },
+ *   0,
+ * );
+ *
+ * state.subscribe((value: number) => {
+ *   console.log(value);
+ * });
+ *
+ * dispatch({ type: 'increment' }); // logs: 1
+ * ```
+ */
+export const createReducer = <S, A>(
+  reducer: Reducer<S, A>,
+  initialState: S,
+): readonly [
+  state: InitializedObservable<S>,
+  dispatch: (action: A) => S,
+  getSnapshot: () => S,
+] => {
+  const state = source<S>(initialState);
+
+  const dispatch = (action: A): S => {
+    const nextState = reducer(state.getSnapshot().value, action);
+
+    state.next(nextState);
+
+    return nextState;
+  };
+
+  const getSnapshot = (): S => state.getSnapshot().value;
+
+  return [state, dispatch, getSnapshot] as const;
+};

package/src/utils/create-state.mts

@@ -0,0 +1,138 @@
+import { type InitializedObservable } from '../core/index.mjs';
+import { createReducer } from './create-reducer.mjs';
+
+type Action<S> = Readonly<
+  | {
+      type: 'set';
+      nextState: S;
+    }
+  | {
+      type: 'update';
+      updateFn: (a: S) => S;
+    }
+>;
+
+const reducer = <S,>(state: S, action: Action<S>): S => {
+  switch (action.type) {
+    case 'set':
+      return action.nextState;
+
+    case 'update':
+      return action.updateFn(state);
+  }
+};
+
+/**
+ * Creates a reactive state container with getter and setter methods.
+ * Provides a simple state management solution with observable state.
+ *
+ * @template S - The type of the state
+ * @param initialState - The initial value of the state
+ * @returns An object containing the state observable and methods to manipulate it
+ *
+ * @example
+ * ```ts
+ * const [state, setState, { updateState, resetState }] = createState(0);
+ *
+ * state.subscribe((value: number) => {
+ *   console.log(value);
+ * }); // logs: 0
+ *
+ * setState(10); // logs: 10
+ *
+ * updateState((prev: number) => prev + 1); // logs: 11
+ *
+ * resetState(); // logs: 0
+ * ```
+ */
+export const createState = <S,>(
+  initialState: S,
+): readonly [
+  state: InitializedObservable<S>,
+  setState: (v: S) => S,
+  Readonly<{
+    updateState: (updateFn: (prev: S) => S) => S;
+    resetState: () => S;
+    getSnapshot: () => S;
+  }>,
+] => {
+  const [state, dispatch, getSnapshot] = createReducer<S, Action<S>>(
+    reducer,
+    initialState,
+  );
+
+  const updateState = (updateFn: (prev: S) => S): S =>
+    dispatch({ type: 'update', updateFn });
+
+  const setState = (nextState: S): S => dispatch({ type: 'set', nextState });
+
+  const resetState = (): S =>
+    dispatch({ type: 'set', nextState: initialState });
+
+  return [
+    state,
+    setState,
+    {
+      updateState,
+      resetState,
+      getSnapshot,
+    },
+  ] as const;
+};
+
+/**
+ * Creates a reactive boolean state with convenient methods for boolean operations.
+ * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
+ *
+ * @param initialState - The initial boolean value
+ * @returns An object with the state observable and boolean-specific methods
+ *
+ * @example
+ * ```ts
+ * const [state, { setTrue, toggle }] = createBooleanState(false);
+ *
+ * state.subscribe((value: boolean) => {
+ *   console.log(value);
+ * }); // logs: false
+ *
+ * setTrue(); // logs: true
+ *
+ * toggle(); // logs: false
+ *
+ * toggle(); // logs: true
+ * ```
+ */
+export const createBooleanState = (
+  initialState: boolean,
+): readonly [
+  state: InitializedObservable<boolean>,
+  Readonly<{
+    setTrue: () => void;
+    setFalse: () => void;
+    setState: (next: boolean) => boolean;
+    toggle: () => boolean;
+    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
+    resetState: () => boolean;
+    getSnapshot: () => boolean;
+  }>,
+] => {
+  const [state, setState, { updateState, resetState, getSnapshot }] =
+    createState(initialState);
+
+  return [
+    state,
+    {
+      setTrue: () => {
+        setState(true);
+      },
+      setFalse: () => {
+        setState(false);
+      },
+      toggle: () => updateState((s) => !s),
+      setState,
+      updateState,
+      resetState,
+      getSnapshot,
+    },
+  ] as const;
+};

package/src/utils/index.mts

@@ -0,0 +1,3 @@
+export * from './create-event-emitter.mjs';
+export * from './create-reducer.mjs';
+export * from './create-state.mjs';