fix(slice): fix slice mode

Author: unadlib

packages/core/README.md

@@ -27,10 +27,10 @@ const useStore = create((set) => ({
 
 ### Store Shape Mode (`sliceMode`)
 
-`create()` uses `sliceMode: 'auto'` by default. `auto` only handles unambiguous
-inputs. If you pass an object whose enumerable values are all functions, you
-must set `sliceMode` explicitly because that shape can mean either a plain store
-or slices.
+`create()` uses `sliceMode: 'auto'` by default. For backward compatibility,
+`auto` still treats a non-empty object whose enumerable values are all
+functions as slices. That shape is ambiguous with a plain store that only
+contains methods, so you should set `sliceMode` explicitly.
 
 You can force behavior explicitly:
 

packages/core/src/create.ts

@@ -20,6 +20,21 @@ import { wrapStore } from './wrapStore';
 import { handleMainTransport } from './handleMainTransport';
 
 const namespaceMap = new Map<string, boolean>();
+let hasWarnedAmbiguousFunctionMap = false;
+
+const warnAmbiguousFunctionMap = () => {
+  if (
+    hasWarnedAmbiguousFunctionMap ||
+    process.env.NODE_ENV === 'production' ||
+    process.env.NODE_ENV === 'test'
+  ) {
+    return;
+  }
+  hasWarnedAmbiguousFunctionMap = true;
+  console.warn(
+    `sliceMode: 'auto' inferred slices from an object of functions. This shape is ambiguous with a single store that only contains methods. Set sliceMode to 'slices' or 'single' explicitly.`
+  );
+};
 
 /**
  * Create a simple store or a shared store. The shared store can be used in a worker or another thread.
@@ -124,9 +139,8 @@ export const create: Creator = <T extends CreateState>(
           return true;
         }
         if (isFunctionMapObject()) {
-          throw new Error(
-            `sliceMode: 'auto' cannot infer whether an object of functions is a single store or slices. Please set sliceMode to 'single' or 'slices'.`
-          );
+          warnAmbiguousFunctionMap();
+          return true;
         }
         return false;
       };

packages/core/src/interface.ts

@@ -206,8 +206,8 @@ export type StoreOptions<T extends CreateState> = {
   enablePatches?: boolean;
   /**
    * control how createState should be interpreted.
-   * - auto: infer only unambiguous shapes. Object maps whose values are all
-   *   functions must set `sliceMode` explicitly.
+   * - auto: infer from createState shape. Object maps whose values are all
+   *   functions are ambiguous, so prefer setting `sliceMode` explicitly.
    * - slices: force slices mode.
    * - single: force single-store mode.
    */
@@ -222,8 +222,8 @@ export type ClientStoreOptions<T extends CreateState> = {
   middlewares?: Middleware<T>[];
   /**
    * control how createState should be interpreted.
-   * - auto: infer only unambiguous shapes. Object maps whose values are all
-   *   functions must set `sliceMode` explicitly.
+   * - auto: infer from createState shape. Object maps whose values are all
+   *   functions are ambiguous, so prefer setting `sliceMode` explicitly.
    * - slices: force slices mode.
    * - single: force single-store mode.
    */

packages/core/test/index.test.ts

@@ -435,16 +435,25 @@ describe('Store Name Lifecycle', () => {
 });
 
 describe('sliceMode', () => {
-  test('auto mode rejects ambiguous function maps without invoking them', () => {
-    const ping = jest.fn(() => ({ ok: true }));
-    expect(() =>
-      create({
-        ping
-      } as any)
-    ).toThrow(
-      "sliceMode: 'auto' cannot infer whether an object of functions is a single store or slices. Please set sliceMode to 'single' or 'slices'."
-    );
-    expect(ping).not.toHaveBeenCalled();
+  test('auto mode preserves slices inference and warns in development', () => {
+    const prev = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'development';
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      const useStore = create({
+        counter: () => ({
+          count: 0
+        })
+      });
+      expect(useStore.isSliceStore).toBe(true);
+      expect(useStore.getState().counter.count).toBe(0);
+      expect(warn).toHaveBeenCalledWith(
+        "sliceMode: 'auto' inferred slices from an object of functions. This shape is ambiguous with a single store that only contains methods. Set sliceMode to 'slices' or 'single' explicitly."
+      );
+    } finally {
+      warn.mockRestore();
+      process.env.NODE_ENV = prev;
+    }
   });
 
   test('single mode treats function maps as a plain store', () => {