@legendapp/state 3.0.0-alpha.0 → 3.0.0-alpha.2

package/config/enableReactNativeComponents.mjs

@@ -2,54 +2,50 @@ import { useRef } from 'react';
 import { configureReactive, useSelector } from '@legendapp/state/react';
 import { ActivityIndicator, Button, FlatList, Image, Pressable, ScrollView, SectionList, Switch, Text, TextInput, TouchableWithoutFeedback, View } from 'react-native';
 
+// src/config/enableReactNativeComponents.ts
 function enableReactNativeComponents() {
-    configureReactive({
-        components: {
-            ActivityIndicator: ActivityIndicator,
-            Button: Button,
-            FlatList: FlatList,
-            Image: Image,
-            Pressable: Pressable,
-            ScrollView: ScrollView,
-            SectionList: SectionList,
-            Switch: Switch,
-            Text: Text,
-            TextInput: TextInput,
-            TouchableWithoutFeedback: TouchableWithoutFeedback,
-            View: View,
-        },
-        binders: {
-            TextInput: {
-                value: {
-                    handler: 'onChange',
-                    getValue: (e) => e.nativeEvent.text,
-                    defaultValue: '',
-                },
-            },
-            Switch: {
-                value: {
-                    handler: 'onValueChange',
-                    getValue: (e) => e,
-                    defaultValue: false,
-                },
-            },
-            FlatList: {
-                data: {
-                    selector: (propsOut, p) => {
-                        const state = useRef(0);
-                        // Increment renderNum whenever the array changes shallowly
-                        const [renderNum, value] = useSelector(() => [state.current++, p.get(true)]);
-                        // Set extraData to renderNum so that it will re-render when renderNum changes.
-                        // This is necessary because the observable array is mutable so changes to it
-                        // won't trigger re-renders by default.
-                        propsOut.extraData = renderNum;
-                        return value;
-                    },
-                },
-            },
-        },
-    });
+  configureReactive({
+    components: {
+      ActivityIndicator,
+      Button,
+      FlatList,
+      Image,
+      Pressable,
+      ScrollView,
+      SectionList,
+      Switch,
+      Text,
+      TextInput,
+      TouchableWithoutFeedback,
+      View
+    },
+    binders: {
+      TextInput: {
+        value: {
+          handler: "onChange",
+          getValue: (e) => e.nativeEvent.text,
+          defaultValue: ""
+        }
+      },
+      Switch: {
+        value: {
+          handler: "onValueChange",
+          getValue: (e) => e,
+          defaultValue: false
+        }
+      },
+      FlatList: {
+        data: {
+          selector: (propsOut, p) => {
+            const state = useRef(0);
+            const [renderNum, value] = useSelector(() => [state.current++, p.get(true)]);
+            propsOut.extraData = renderNum;
+            return value;
+          }
+        }
+      }
+    }
+  });
 }
 
 export { enableReactNativeComponents };
-//# sourceMappingURL=enableReactNativeComponents.mjs.map

package/config/enableReactTracking.d.mts

@@ -0,0 +1,7 @@
+interface ReactTrackingOptions {
+    auto?: boolean;
+    warnUnobserved?: boolean;
+}
+declare function enableReactTracking({ auto, warnUnobserved }: ReactTrackingOptions): void;
+
+export { enableReactTracking };

package/config/enableReactTracking.d.ts

@@ -2,5 +2,6 @@ interface ReactTrackingOptions {
     auto?: boolean;
     warnUnobserved?: boolean;
 }
-export declare function enableReactTracking({ auto, warnUnobserved }: ReactTrackingOptions): void;
-export {};
+declare function enableReactTracking({ auto, warnUnobserved }: ReactTrackingOptions): void;
+
+export { enableReactTracking };

package/config/enableReactTracking.js

@@ -4,46 +4,41 @@ var state = require('@legendapp/state');
 var react$1 = require('@legendapp/state/react');
 var react = require('react');
 
+// src/config/enableReactTracking.ts
 function enableReactTracking({ auto, warnUnobserved }) {
-    const { get } = state.internal;
-    if (auto || (process.env.NODE_ENV === 'development' && warnUnobserved)) {
-        const ReactRenderContext = react.createContext(0);
-        const needsSelector = () => {
-            // If we're already tracking then we definitely don't need useSelector
-            if (!state.tracking.current) {
-                try {
-                    // If there's no dispatcher we're definitely not in React
-                    // This is an optimization to not need to run useContext. If in a future React version
-                    // this works differently we can change it or just remove it.
-                    const dispatcher = react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher.current;
-                    if (dispatcher) {
-                        // If there's a dispatcher then we may be inside of a hook.
-                        // Attempt a useContext hook, which will throw an error if outside of render.
-                        react.useContext(ReactRenderContext);
-                        return true;
-                    }
-                }
-                catch (_a) { } // eslint-disable-line no-empty
+  const { get } = state.internal;
+  if (auto || process.env.NODE_ENV === "development" && warnUnobserved) {
+    const ReactRenderContext = react.createContext(0);
+    const needsSelector = () => {
+      if (!state.tracking.current) {
+        try {
+          const dispatcher = react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher.current;
+          if (dispatcher) {
+            react.useContext(ReactRenderContext);
+            return true;
+          }
+        } catch (e) {
+        }
+      }
+      return false;
+    };
+    state.configureLegendState({
+      observableFunctions: {
+        get: (node, options) => {
+          if (needsSelector()) {
+            if (auto) {
+              return react$1.useSelector(() => get(node, options), state.isObject(options) ? options : void 0);
+            } else if (process.env.NODE_ENV === "development" && warnUnobserved) {
+              console.warn(
+                "[legend-state] Detected a `get()` call in an unobserved component. You may want to wrap it in observer: https://legendapp.com/open-source/state/react-api/#observer-hoc"
+              );
             }
-            return false;
-        };
-        state.configureLegendState({
-            observableFunctions: {
-                get: (node, options) => {
-                    if (needsSelector()) {
-                        if (auto) {
-                            return react$1.useSelector(() => get(node, options), state.isObject(options) ? options : undefined);
-                        }
-                        else if (process.env.NODE_ENV === 'development' && warnUnobserved) {
-                            console.warn('[legend-state] Detected a `get()` call in an unobserved component. You may want to wrap it in observer: https://legendapp.com/open-source/state/react-api/#observer-hoc');
-                        }
-                    }
-                    return get(node, options);
-                },
-            },
-        });
-    }
+          }
+          return get(node, options);
+        }
+      }
+    });
+  }
 }
 
 exports.enableReactTracking = enableReactTracking;
-//# sourceMappingURL=enableReactTracking.js.map

package/config/enableReactTracking.mjs

@@ -2,46 +2,41 @@ import { configureLegendState, isObject, internal, tracking } from '@legendapp/s
 import { useSelector } from '@legendapp/state/react';
 import { createContext, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, useContext } from 'react';
 
+// src/config/enableReactTracking.ts
 function enableReactTracking({ auto, warnUnobserved }) {
-    const { get } = internal;
-    if (auto || (process.env.NODE_ENV === 'development' && warnUnobserved)) {
-        const ReactRenderContext = createContext(0);
-        const needsSelector = () => {
-            // If we're already tracking then we definitely don't need useSelector
-            if (!tracking.current) {
-                try {
-                    // If there's no dispatcher we're definitely not in React
-                    // This is an optimization to not need to run useContext. If in a future React version
-                    // this works differently we can change it or just remove it.
-                    const dispatcher = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher.current;
-                    if (dispatcher) {
-                        // If there's a dispatcher then we may be inside of a hook.
-                        // Attempt a useContext hook, which will throw an error if outside of render.
-                        useContext(ReactRenderContext);
-                        return true;
-                    }
-                }
-                catch (_a) { } // eslint-disable-line no-empty
+  const { get } = internal;
+  if (auto || process.env.NODE_ENV === "development" && warnUnobserved) {
+    const ReactRenderContext = createContext(0);
+    const needsSelector = () => {
+      if (!tracking.current) {
+        try {
+          const dispatcher = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher.current;
+          if (dispatcher) {
+            useContext(ReactRenderContext);
+            return true;
+          }
+        } catch (e) {
+        }
+      }
+      return false;
+    };
+    configureLegendState({
+      observableFunctions: {
+        get: (node, options) => {
+          if (needsSelector()) {
+            if (auto) {
+              return useSelector(() => get(node, options), isObject(options) ? options : void 0);
+            } else if (process.env.NODE_ENV === "development" && warnUnobserved) {
+              console.warn(
+                "[legend-state] Detected a `get()` call in an unobserved component. You may want to wrap it in observer: https://legendapp.com/open-source/state/react-api/#observer-hoc"
+              );
             }
-            return false;
-        };
-        configureLegendState({
-            observableFunctions: {
-                get: (node, options) => {
-                    if (needsSelector()) {
-                        if (auto) {
-                            return useSelector(() => get(node, options), isObject(options) ? options : undefined);
-                        }
-                        else if (process.env.NODE_ENV === 'development' && warnUnobserved) {
-                            console.warn('[legend-state] Detected a `get()` call in an unobserved component. You may want to wrap it in observer: https://legendapp.com/open-source/state/react-api/#observer-hoc');
-                        }
-                    }
-                    return get(node, options);
-                },
-            },
-        });
-    }
+          }
+          return get(node, options);
+        }
+      }
+    });
+  }
 }
 
 export { enableReactTracking };
-//# sourceMappingURL=enableReactTracking.mjs.map

package/config/enableReactUse.d.mts

@@ -0,0 +1,10 @@
+import { UseSelectorOptions } from '@legendapp/state/react';
+
+declare function enableReactUse(): void;
+declare module '@legendapp/state' {
+    interface ImmutableObservableBase<T> {
+        use(options?: UseSelectorOptions): T;
+    }
+}
+
+export { enableReactUse };

package/config/enableReactUse.d.ts

@@ -1,7 +1,10 @@
 import { UseSelectorOptions } from '@legendapp/state/react';
-export declare function enableReactUse(): void;
+
+declare function enableReactUse(): void;
 declare module '@legendapp/state' {
     interface ImmutableObservableBase<T> {
         use(options?: UseSelectorOptions): T;
     }
 }
+
+export { enableReactUse };

package/config/enableReactUse.js

@@ -3,21 +3,22 @@
 var state = require('@legendapp/state');
 var react = require('@legendapp/state/react');
 
-// TODO: Deprecated, remove in v4
-let didWarn = false;
+// src/config/enableReactUse.ts
+var didWarn = false;
 function enableReactUse() {
-    state.configureLegendState({
-        observableFunctions: {
-            use: (node, options) => {
-                if (process.env.NODE_ENV === 'development' && !didWarn) {
-                    didWarn = true;
-                    console.warn('[legend-state] enableReactUse() is deprecated. Please switch to using get() with observer, which is safer and more efficient. See https://legendapp.com/open-source/state/v3/react/react-api/');
-                }
-                return react.useSelector(state.internal.getProxy(node), options);
-            },
-        },
-    });
+  state.configureLegendState({
+    observableFunctions: {
+      use: (node, options) => {
+        if (process.env.NODE_ENV === "development" && !didWarn) {
+          didWarn = true;
+          console.warn(
+            "[legend-state] enableReactUse() is deprecated. Please switch to using get() with observer, which is safer and more efficient. See https://legendapp.com/open-source/state/v3/react/react-api/"
+          );
+        }
+        return react.useSelector(state.internal.getProxy(node), options);
+      }
+    }
+  });
 }
 
 exports.enableReactUse = enableReactUse;
-//# sourceMappingURL=enableReactUse.js.map

package/config/enableReactUse.mjs

@@ -1,21 +1,22 @@
 import { configureLegendState, internal } from '@legendapp/state';
 import { useSelector } from '@legendapp/state/react';
 
-// TODO: Deprecated, remove in v4
-let didWarn = false;
+// src/config/enableReactUse.ts
+var didWarn = false;
 function enableReactUse() {
-    configureLegendState({
-        observableFunctions: {
-            use: (node, options) => {
-                if (process.env.NODE_ENV === 'development' && !didWarn) {
-                    didWarn = true;
-                    console.warn('[legend-state] enableReactUse() is deprecated. Please switch to using get() with observer, which is safer and more efficient. See https://legendapp.com/open-source/state/v3/react/react-api/');
-                }
-                return useSelector(internal.getProxy(node), options);
-            },
-        },
-    });
+  configureLegendState({
+    observableFunctions: {
+      use: (node, options) => {
+        if (process.env.NODE_ENV === "development" && !didWarn) {
+          didWarn = true;
+          console.warn(
+            "[legend-state] enableReactUse() is deprecated. Please switch to using get() with observer, which is safer and more efficient. See https://legendapp.com/open-source/state/v3/react/react-api/"
+          );
+        }
+        return useSelector(internal.getProxy(node), options);
+      }
+    }
+  });
 }
 
 export { enableReactUse };
-//# sourceMappingURL=enableReactUse.mjs.map

package/config/{enable$GetSet.d.ts → enable_GetSet.d.mts}

@@ -1,8 +1,10 @@
-export declare function enable$GetSet(): void;
-export declare const enableDirectAccess: typeof enable$GetSet;
+declare function enable$GetSet(): void;
+declare const enableDirectAccess: typeof enable$GetSet;
 declare module '@legendapp/state' {
     interface ImmutableObservableBase<T> {
         get $(): T;
         set $(value: T | null | undefined);
     }
 }
+
+export { enable$GetSet, enableDirectAccess };

package/config/enable_GetSet.d.ts

@@ -0,0 +1,10 @@
+declare function enable$GetSet(): void;
+declare const enableDirectAccess: typeof enable$GetSet;
+declare module '@legendapp/state' {
+    interface ImmutableObservableBase<T> {
+        get $(): T;
+        set $(value: T | null | undefined);
+    }
+}
+
+export { enable$GetSet, enableDirectAccess };

package/config/enable_PeekAssign.d.mts

@@ -0,0 +1,10 @@
+declare function enable_PeekAssign(): void;
+declare const enableDirectAccess: typeof enable_PeekAssign;
+declare module '@legendapp/state' {
+    interface ImmutableObservableBase<T> {
+        get _(): T;
+        set _(value: T | null | undefined);
+    }
+}
+
+export { enableDirectAccess, enable_PeekAssign };

package/config/enable_PeekAssign.d.ts

@@ -1,8 +1,10 @@
-export declare function enable_PeekAssign(): void;
-export declare const enableDirectAccess: typeof enable_PeekAssign;
+declare function enable_PeekAssign(): void;
+declare const enableDirectAccess: typeof enable_PeekAssign;
 declare module '@legendapp/state' {
     interface ImmutableObservableBase<T> {
         get _(): T;
         set _(value: T | null | undefined);
     }
 }
+
+export { enableDirectAccess, enable_PeekAssign };

package/config/enable_PeekAssign.js

@@ -2,23 +2,22 @@
 
 var state = require('@legendapp/state');
 
+// src/config/enable_PeekAssign.ts
 function enable_PeekAssign() {
-    state.configureLegendState({
-        observableProperties: {
-            _: {
-                get(node) {
-                    return state.internal.peek(node);
-                },
-                set(node, value) {
-                    state.internal.setNodeValue(node, value);
-                },
-            },
+  state.configureLegendState({
+    observableProperties: {
+      _: {
+        get(node) {
+          return state.internal.peek(node);
         },
-    });
+        set(node, value) {
+          state.internal.setNodeValue(node, value);
+        }
+      }
+    }
+  });
 }
-// TODOv4 deprecate
-const enableDirectAccess = enable_PeekAssign;
+var enableDirectAccess = enable_PeekAssign;
 
 exports.enableDirectAccess = enableDirectAccess;
 exports.enable_PeekAssign = enable_PeekAssign;
-//# sourceMappingURL=enable_PeekAssign.js.map

package/config/enable_PeekAssign.mjs

@@ -1,21 +1,20 @@
 import { configureLegendState, internal } from '@legendapp/state';
 
+// src/config/enable_PeekAssign.ts
 function enable_PeekAssign() {
-    configureLegendState({
-        observableProperties: {
-            _: {
-                get(node) {
-                    return internal.peek(node);
-                },
-                set(node, value) {
-                    internal.setNodeValue(node, value);
-                },
-            },
+  configureLegendState({
+    observableProperties: {
+      _: {
+        get(node) {
+          return internal.peek(node);
         },
-    });
+        set(node, value) {
+          internal.setNodeValue(node, value);
+        }
+      }
+    }
+  });
 }
-// TODOv4 deprecate
-const enableDirectAccess = enable_PeekAssign;
+var enableDirectAccess = enable_PeekAssign;
 
 export { enableDirectAccess, enable_PeekAssign };
-//# sourceMappingURL=enable_PeekAssign.mjs.map

package/helpers/pageHash.d.mts

@@ -0,0 +1,9 @@
+import { Observable } from '@legendapp/state';
+
+interface Options {
+    setter: 'pushState' | 'replaceState' | 'hash';
+}
+declare function configurePageHash(options: Options): void;
+declare const pageHash: Observable<string>;
+
+export { configurePageHash, pageHash };

package/helpers/pageHash.d.ts

@@ -1,7 +1,9 @@
 import { Observable } from '@legendapp/state';
+
 interface Options {
     setter: 'pushState' | 'replaceState' | 'hash';
 }
 declare function configurePageHash(options: Options): void;
 declare const pageHash: Observable<string>;
+
 export { configurePageHash, pageHash };

package/helpers/pageHash.js

@@ -2,40 +2,35 @@
 
 var state = require('@legendapp/state');
 
-let _options = { setter: 'hash' };
+// src/helpers/pageHash.ts
+var _options = { setter: "hash" };
 function configurePageHash(options) {
-    _options = options;
+  _options = options;
 }
-const hasWindow = typeof window !== 'undefined';
-const pageHash = state.observable(hasWindow ? window.location.hash.slice(1) : '');
+var hasWindow = typeof window !== "undefined";
+var pageHash = state.observable(hasWindow ? window.location.hash.slice(1) : "");
 if (hasWindow) {
-    let isSetting = false;
-    // Set the page hash when the observable changes
-    pageHash.onChange(({ value }) => {
-        if (!isSetting) {
-            const hash = '#' + value;
-            const setter = (_options === null || _options === void 0 ? void 0 : _options.setter) || 'hash';
-            if (setter === 'pushState') {
-                history.pushState(null, null, hash);
-            }
-            else if (setter === 'replaceState') {
-                history.replaceState(null, null, hash);
-            }
-            else {
-                location.hash = hash;
-            }
-        }
-    });
-    // Update the observable whenever the hash changes
-    const cb = () => {
-        isSetting = true;
-        pageHash.set(window.location.hash.slice(1));
-        isSetting = false;
-    };
-    // Subscribe to window hashChange event
-    window.addEventListener('hashchange', cb);
+  let isSetting = false;
+  pageHash.onChange(({ value }) => {
+    if (!isSetting) {
+      const hash = "#" + value;
+      const setter = (_options == null ? void 0 : _options.setter) || "hash";
+      if (setter === "pushState") {
+        history.pushState(null, null, hash);
+      } else if (setter === "replaceState") {
+        history.replaceState(null, null, hash);
+      } else {
+        location.hash = hash;
+      }
+    }
+  });
+  const cb = () => {
+    isSetting = true;
+    pageHash.set(window.location.hash.slice(1));
+    isSetting = false;
+  };
+  window.addEventListener("hashchange", cb);
 }
 
 exports.configurePageHash = configurePageHash;
 exports.pageHash = pageHash;
-//# sourceMappingURL=pageHash.js.map