pocket-state 0.1.17 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pocket-state",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "tiny global store",
   "main": "src/index",
   "codegenConfig": {

package/src/globalState/{create.ts → create-hook.ts}

@@ -1,6 +1,6 @@
-import { useMemo } from "react";
-import { useStore } from "./hooks";
-import { Store } from "./type";
+import {useMemo} from 'react';
+import {useStore} from './hooks';
+import {Store} from './type';
 
 /**
  * Creates a custom React hook for a store, giving you access to the store API
@@ -27,14 +27,14 @@ import { Store } from "./type";
  *   2. `useHook(selector)` – Returns `{ value, ...api }` where `value` is the selected state. Re-renders on selected value changes.
  */
 export function createHook<T>(store: Store<T>) {
-  const api = { ...store };
+  const api = {...store};
 
   function useBoundStore(): typeof api;
-  function useBoundStore<S>(selector: (state: T) => S): { value: S } & typeof api;
+  function useBoundStore<S>(selector: (state: T) => S): {value: S} & typeof api;
   function useBoundStore<S = T>(selector?: (state: T) => S) {
     if (!selector) return api;
     const value = useStore(store, selector);
-    return useMemo(() => ({ value, ...api }), [value]);
+    return useMemo(() => ({value, ...api}), [value]);
   }
 
   return useBoundStore;

package/src/globalState/hooks.ts

@@ -7,19 +7,17 @@ export function useStore<T, S = T>(
 ): S {
   const sel = selector ?? ((s: T) => s as unknown as S);
 
+
   const lastStateRef = useRef<T>(store.getValue());
   const lastSliceRef = useRef<S>(sel(lastStateRef.current));
 
-  const subscribe = useCallback(
-    (onChange: () => void) => {
-      return store.subscribe(sel, (nextSlice: S) => {
-        lastStateRef.current = store.getValue();
-        lastSliceRef.current = nextSlice;
-        onChange();
-      });
-    },
-    [store, sel],
-  );
+  const subscribe = useCallback((onChange: () => void) => {
+    return store.subscribe(sel, (nextSlice: S) => {
+      lastStateRef.current = store.getValue();
+      lastSliceRef.current = nextSlice;
+      onChange();
+    });
+  }, []);
 
   const getSnapshot = useCallback(() => {
     const s = store.getValue();
@@ -28,7 +26,7 @@ export function useStore<T, S = T>(
       lastSliceRef.current = sel(s);
     }
     return lastSliceRef.current;
-  }, [store, sel]);
+  }, []);
 
   return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }

package/src/globalState/store.ts

@@ -1,8 +1,11 @@
 // store.ts
 import {IEventEmitter, Listener, Middleware, Store, UseStoreGet} from './type';
-import {EventEmitter} from './event';
+import {EventEmitter} from '../utils/event';
 import {Draft, produce} from 'immer';
-import {shallow} from './shallowEqual';
+import {shallow} from '../utils/shallowEqual';
+import cloneObject from '../utils/cloneObject';
+import isPromise from '../utils/isPromise';
+import isArray from '../utils/isArray';
 
 export function createStore<T>(
   initialState: T,
@@ -10,7 +13,7 @@ export function createStore<T>(
   equalityFn?: (a: any, b: any) => boolean,
 ): Store<T> {
   const emitter: IEventEmitter = new EventEmitter();
-  const _initialState = Array.isArray(initialState)
+  const _initialState = isArray(initialState)
     ? (initialState as any).slice()
     : initialState && typeof initialState === 'object'
     ? {...initialState}
@@ -76,7 +79,7 @@ export function createStore<T>(
     patch: Partial<T> | ((state: T) => Partial<T> | Promise<Partial<T>>),
   ): void {
     let resolved = typeof patch === 'function' ? patch(state) : patch;
-    if (resolved instanceof Promise) {
+    if (isPromise(resolved)) {
       resolved
         .then(res => {
           if (res && typeof res === 'object') {
@@ -122,21 +125,13 @@ export function createStore<T>(
     }
   }
 
-  function reset(): void;
-  function reset(initialValue?: T | Partial<T>): void;
   function reset(initialValue?: T | Partial<T>) {
     const isObj = (
       v: unknown,
     ): v is Record<string | symbol | number, unknown> =>
       typeof v === 'object' && v !== null;
 
-    const cloneShallow = <U>(src: U): U => {
-      if (Array.isArray(src)) return (src as any).slice();
-      if (isObj(src)) return {...(src as any)} as U;
-      return src;
-    };
-
-    let next = cloneShallow(initialState) as T;
+    let next = cloneObject(initialState) as T;
     if (initialValue !== undefined) {
       if (Array.isArray(initialValue)) {
         next = (initialValue as any).slice();

package/src/globalState/type.d.ts

@@ -1,5 +1,11 @@
 import {Draft} from 'immer';
 
+interface FileList {
+  readonly length: number;
+  item(index: number): File | null;
+  [index: number]: File;
+}
+
 /**
  * A callback invoked when an event is emitted with a payload of type `T`.
  * Keep listeners pure and fast. Long-running side effects should live in
@@ -200,6 +206,8 @@ export interface Store<T> {
 
   /** Get number of subscriber for current store */
   getNumberOfSubscriber(): number;
+
+  /** */
 }
 
 /**

package/src/index.tsx

@@ -1,5 +1,5 @@
 export * from './globalState/store';
 export * from './globalState/hooks';
-export * from './globalState/create';
+export * from './globalState/create-hook';
 export type * from './globalState/type';
-export * from './globalState/event';
+export * from './utils/event';

package/src/utils/cloneObject.ts

@@ -0,0 +1,25 @@
+import isArray from './isArray';
+import isObject from './isObject';
+import isPlainObject from './isPlainObject';
+
+export default function cloneObject<T>(data: T): T {
+  let copy: any;
+
+  if (data instanceof Date) {
+    copy = new Date(data);
+  } else if (isArray(data) || isObject(data)) {
+    copy = isArray(data) ? [] : Object.create(Object.getPrototypeOf(data));
+    if (!isArray(data) && !isPlainObject(data)) {
+      copy = data;
+    } else {
+      for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+          copy[key] = cloneObject(data[key]);
+        }
+      }
+    }
+  } else {
+    return data;
+  }
+  return copy;
+}

package/src/{globalState → utils}/event.ts

@@ -1,5 +1,5 @@
 // event.ts
-import {IEventEmitter, Listener} from './type';
+import {IEventEmitter, Listener} from '../globalState/type';
 
 export class EventEmitter implements IEventEmitter {
   private events = new Map<string, Set<Listener<any>>>();

package/src/utils/isArray.ts

@@ -0,0 +1,2 @@
+export default (value: unknown): value is Array<unknown> =>
+  Array.isArray(value);

package/src/utils/isDateObject.ts

@@ -0,0 +1 @@
+export default (value: unknown): value is Date => value instanceof Date;

package/src/utils/isFunction.ts

@@ -0,0 +1,2 @@
+export default (value: unknown): value is Function =>
+  typeof value === 'function';

package/src/utils/isNullOrUndefined.ts

@@ -0,0 +1 @@
+export default (value: unknown): value is null | undefined => value == null;

package/src/utils/isObject.ts

@@ -0,0 +1,11 @@
+import isDateObject from './isDateObject';
+import isNullOrUndefined from './isNullOrUndefined';
+
+export const isObjectType = (value: unknown): value is object =>
+  typeof value === 'object';
+
+export default <T extends object>(value: unknown): value is T =>
+  !isNullOrUndefined(value) &&
+  !Array.isArray(value) &&
+  isObjectType(value) &&
+  !isDateObject(value);

package/src/utils/isPlainObject.ts

@@ -0,0 +1,10 @@
+import isObject from './isObject';
+
+export default (tempObject: object) => {
+  const prototypeCopy =
+    tempObject.constructor && tempObject.constructor.prototype;
+
+  return (
+    isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf')
+  );
+};

package/src/utils/isPromise.ts

@@ -0,0 +1,2 @@
+export default (value: unknown): value is Promise<any> =>
+  value instanceof Promise;