muya 1.1.0 → 2.0.0-beta.2

package/src/create-emitter.ts

@@ -1,24 +0,0 @@
-export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void
-export interface Emitter<T, R = T, P = undefined> {
-  subscribe: EmitterSubscribe<P>
-  getSnapshot: () => R
-  emit: (...params: P[]) => void
-}
-
-export function createEmitter<T, R = T, P = undefined>(getSnapshot: () => R): Emitter<T, R, P> {
-  const listeners = new Set<(...params: P[]) => void>()
-  return {
-    subscribe: (listener) => {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    emit: (...params) => {
-      for (const listener of listeners) {
-        listener(...params)
-      }
-    },
-    getSnapshot,
-  }
-}

package/src/create-getter-state.ts

@@ -1,19 +0,0 @@
-import type { BaseState, GetterState } from './types'
-import { useStateValue } from './use-state-value'
-
-interface Options<T> {
-  readonly baseState: BaseState<T>
-}
-export function createGetterState<T>(options: Options<T>): GetterState<T> {
-  const { baseState } = options
-  const useSliceState: GetterState<T> = (useSelector, isEqualHook) => {
-    return useStateValue(useSliceState, useSelector, isEqualHook)
-  }
-  useSliceState.__internal = baseState.__internal
-  useSliceState.getState = baseState.getState
-  useSliceState.reset = baseState.reset
-  useSliceState.select = baseState.select
-  useSliceState.merge = baseState.merge
-  useSliceState.subscribe = baseState.subscribe
-  return useSliceState
-}

package/src/create.ts

@@ -1,102 +0,0 @@
-import { createEmitter } from './create-emitter'
-import type { SetValue, SetterState, StateDataInternal, DefaultValue, GetterState, IsEqual, UpdateValue } from './types'
-import { getDefaultValue } from './types'
-import { isEqualBase, isObject, isPromise, isSetValueFunction } from './is'
-import { createBaseState } from './create-base-state'
-import { createGetterState } from './create-getter-state'
-
-/**
- * Creates a basic atom state.
- * @param defaultValue - The initial state value.
- * @param options - Optional settings for the state (e.g., isEqual, onSet).
- * @returns A state object that can be used as a hook and provides state management methods.
- * @example
- * ```typescript
- * // Global scope
- * const counterState = state(0);
- * const userState = state({ name: 'John', age: 20 });
- *
- * // React component
- * const counter = counterState(); // Use as a hook
- * const user = userState();
- *
- * // Access partial data from the state using slice
- * const userAge = userState.slice((state) => state.age)();
- * ```
- */
-
-export function create<T>(defaultValue: DefaultValue<T>, isEqual: IsEqual<T> = isEqualBase): SetterState<Awaited<T>> {
-  function resolveSetter(value: T, stateSetter: SetValue<T>): T {
-    if (isSetValueFunction(stateSetter)) {
-      return stateSetter(value)
-    }
-    return stateSetter
-  }
-
-  const stateData: StateDataInternal<T> = {
-    updateVersion: 0,
-    value: undefined,
-  }
-
-  function getValue(): T {
-    if (stateData.value === undefined) {
-      stateData.value = getDefaultValue(defaultValue)
-    }
-    return stateData.value
-  }
-  function get(): T {
-    const stateValue = getValue()
-    if (isPromise(stateValue)) {
-      stateValue.then((data) => {
-        stateData.value = data as Awaited<T>
-        emitter.emit()
-      })
-    }
-    return stateValue
-  }
-
-  function set(stateValue: SetValue<T>) {
-    const stateValueData = getValue()
-    const newState = resolveSetter(stateValueData, stateValue)
-    const isEqualResult = isEqual?.(stateValueData, newState)
-    if (isEqualResult || newState === stateValueData) {
-      return
-    }
-    stateData.updateVersion++
-    stateData.value = newState
-    emitter.emit()
-  }
-
-  function update(stateValue: UpdateValue<T>) {
-    if (isObject(stateValue)) {
-      return set((previousState) => {
-        return { ...previousState, ...stateValue }
-      })
-    }
-    set(stateValue as T)
-  }
-
-  const emitter = createEmitter<T>(get)
-
-  const baseState = createBaseState({
-    emitter,
-    getGetterState: () => setterState,
-    getState: get,
-    reset() {
-      const value = getDefaultValue(defaultValue)
-      if (isPromise(value)) {
-        value.then((data) => {
-          set(data as T)
-        })
-        return
-      }
-      set(value)
-    },
-  })
-
-  const getterState: GetterState<T> = createGetterState<T>({ baseState })
-  const setterState: SetterState<T> = getterState as SetterState<T>
-  setterState.setState = set
-  setterState.updateState = update
-  return setterState as SetterState<Awaited<T>>
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './types'
-export { create } from './create'
-export { select } from './select'
-export { merge } from './merge'
-export { useStateValue } from './use-state-value'
-export { shallow } from './shallow'

package/src/is.ts

@@ -1,36 +0,0 @@
-import type { Ref, Setter, SetValue } from './types'
-
-export function isPromise(value: unknown): value is Promise<unknown> {
-  return value instanceof Promise
-}
-export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
-  return typeof value === 'function'
-}
-export function isSetValueFunction<T>(value: SetValue<T>): value is Setter<T> {
-  return typeof value === 'function'
-}
-export function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
-}
-export function isRef<T>(value: unknown): value is Ref<T> {
-  return isObject(value) && value.isRef === true
-}
-
-export function isMap(value: unknown): value is Map<unknown, unknown> {
-  return value instanceof Map
-}
-
-export function isSet(value: unknown): value is Set<unknown> {
-  return value instanceof Set
-}
-
-export function isArray(value: unknown): value is Array<unknown> {
-  return Array.isArray(value)
-}
-
-export function isEqualBase<T>(valueA: T, valueB: T): boolean {
-  if (valueA === valueB) {
-    return true
-  }
-  return !!Object.is(valueA, valueB)
-}

package/src/merge.ts

@@ -1,41 +0,0 @@
-import { createBaseState } from './create-base-state'
-import { createEmitter } from './create-emitter'
-import { createGetterState } from './create-getter-state'
-import { isEqualBase } from './is'
-import type { IsEqual, GetterState } from './types'
-
-export function merge<T1, T2, S>(
-  state1: GetterState<T1>,
-  state2: GetterState<T2>,
-  selector: (value1: T1, value2: T2) => S,
-  isEqual: IsEqual<S> = isEqualBase,
-): GetterState<S> {
-  let previousData: S | undefined
-  const emitter = createEmitter(() => {
-    const data = selector(state1.getState(), state2.getState())
-    if (previousData !== undefined && isEqual(previousData, data)) {
-      return previousData
-    }
-    previousData = data
-    return data
-  })
-  state1.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-  state2.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-
-  const baseState = createBaseState<S>({
-    emitter,
-    getGetterState: () => getterState,
-    getState: () => selector(state1.getState(), state2.getState()),
-    reset() {
-      state1.reset()
-      state2.reset()
-    },
-  })
-
-  const getterState: GetterState<S> = createGetterState<S>({ baseState })
-  return getterState
-}

package/src/select.ts

@@ -1,33 +0,0 @@
-import { createBaseState } from './create-base-state'
-import { createEmitter } from './create-emitter'
-import { createGetterState } from './create-getter-state'
-import { isEqualBase } from './is'
-import type { IsEqual, GetterState } from './types'
-
-export function select<T, S>(
-  state: GetterState<T>,
-  selector: (value: T) => S,
-  isEqual: IsEqual<S> = isEqualBase,
-): GetterState<S> {
-  let previousData: S | undefined
-  const emitter = createEmitter(() => {
-    const data = selector(state.getState())
-    if (previousData !== undefined && isEqual(previousData, data)) {
-      return previousData
-    }
-    previousData = data
-    return data
-  })
-  state.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-
-  const baseState = createBaseState<S>({
-    emitter,
-    getGetterState: () => getterState,
-    getState: () => selector(state.getState()),
-    reset: state.reset,
-  })
-  const getterState: GetterState<S> = createGetterState<S>({ baseState })
-  return getterState
-}