@ngrx/signals 19.0.0 → 19.1.0

package/fesm2022/ngrx-signals.mjs

@@ -64,13 +64,25 @@ function signalMethod(processingFn, config) {
     const sourceInjector = config?.injector ?? inject(Injector);
     const signalMethodFn = (input, config) => {
         if (isSignal(input)) {
-            const instanceInjector = config?.injector ?? getCallerInjector() ?? sourceInjector;
-            const watcher = effect((onCleanup) => {
+            const callerInjector = getCallerInjector();
+            if (typeof ngDevMode !== 'undefined' &&
+                ngDevMode &&
+                config?.injector === undefined &&
+                callerInjector === undefined) {
+                console.warn('@ngrx/signals: The function returned by signalMethod was called', 'outside the injection context with a signal. This may lead to', 'a memory leak. Make sure to call it within the injection context', '(e.g. in a constructor or field initializer) or pass an injector', 'explicitly via the config parameter.\n\nFor more information, see:', 'https://ngrx.io/guide/signals/signal-method#automatic-cleanup');
+            }
+            const instanceInjector = config?.injector ?? callerInjector ?? sourceInjector;
+            const watcher = effect(() => {
                 const value = input();
                 untracked(() => processingFn(value));
-                onCleanup(() => watchers.splice(watchers.indexOf(watcher), 1));
             }, { injector: instanceInjector });
             watchers.push(watcher);
+            instanceInjector.get(DestroyRef).onDestroy(() => {
+                const ix = watchers.indexOf(watcher);
+                if (ix !== -1) {
+                    watchers.splice(ix, 1);
+                }
+            });
             return watcher;
         }
         else {
@@ -86,47 +98,20 @@ function getCallerInjector() {
         return inject(Injector);
     }
     catch {
-        return null;
+        return undefined;
     }
 }
 
-function deepFreeze(target) {
-    Object.freeze(target);
-    const targetIsFunction = typeof target === 'function';
-    Object.getOwnPropertyNames(target).forEach((prop) => {
-        // Ignore Ivy properties, ref: https://github.com/ngrx/platform/issues/2109#issuecomment-582689060
-        if (prop.startsWith('ɵ')) {
-            return;
-        }
-        if (hasOwnProperty(target, prop) &&
-            (targetIsFunction
-                ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments'
-                : true)) {
-            const propValue = target[prop];
-            if ((isObjectLike(propValue) || typeof propValue === 'function') &&
-                !Object.isFrozen(propValue)) {
-                deepFreeze(propValue);
-            }
-        }
-    });
-    return target;
-}
-function freezeInDevMode(target) {
-    return ngDevMode ? deepFreeze(target) : target;
-}
-function hasOwnProperty(target, propertyName) {
-    return isObjectLike(target)
-        ? Object.prototype.hasOwnProperty.call(target, propertyName)
-        : false;
-}
-function isObjectLike(target) {
-    return typeof target === 'object' && target !== null;
-}
-
 const STATE_WATCHERS = new WeakMap();
 const STATE_SOURCE = Symbol('STATE_SOURCE');
+function isWritableStateSource(stateSource) {
+    return ('set' in stateSource[STATE_SOURCE] &&
+        'update' in stateSource[STATE_SOURCE] &&
+        typeof stateSource[STATE_SOURCE].set === 'function' &&
+        typeof stateSource[STATE_SOURCE].update === 'function');
+}
 function patchState(stateSource, ...updaters) {
-    stateSource[STATE_SOURCE].update((currentState) => updaters.reduce((nextState, updater) => freezeInDevMode({
+    stateSource[STATE_SOURCE].update((currentState) => updaters.reduce((nextState, updater) => ({
         ...nextState,
         ...(typeof updater === 'function' ? updater(nextState) : updater),
     }), currentState));
@@ -167,7 +152,7 @@ function removeWatcher(stateSource, watcher) {
 }
 
 function signalState(initialState) {
-    const stateSource = signal(freezeInDevMode(initialState));
+    const stateSource = signal(initialState);
     const signalState = toDeepSignal(stateSource.asReadonly());
     Object.defineProperty(signalState, STATE_SOURCE, {
         value: stateSource,
@@ -185,9 +170,13 @@ function signalStore(...args) {
         constructor() {
             const innerStore = features.reduce((store, feature) => feature(store), getInitialInnerStore());
             const { stateSignals, props, methods, hooks } = innerStore;
-            const storeMembers = { ...stateSignals, ...props, ...methods };
+            const storeMembers = {
+                ...stateSignals,
+                ...props,
+                ...methods,
+            };
             this[STATE_SOURCE] = innerStore[STATE_SOURCE];
-            for (const key in storeMembers) {
+            for (const key of Reflect.ownKeys(storeMembers)) {
                 this[key] = storeMembers[key];
             }
             const { onInit, onDestroy } = hooks;
@@ -198,10 +187,10 @@ function signalStore(...args) {
                 inject(DestroyRef).onDestroy(onDestroy);
             }
         }
-        /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: SignalStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-        /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: SignalStore, providedIn: config.providedIn || null });
+        /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.3", ngImport: i0, type: SignalStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+        /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.3", ngImport: i0, type: SignalStore, providedIn: config.providedIn || null });
     }
-    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: SignalStore, decorators: [{
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.3", ngImport: i0, type: SignalStore, decorators: [{
                 type: Injectable,
                 args: [{ providedIn: config.providedIn || null }]
             }], ctorParameters: () => [] });
@@ -228,7 +217,7 @@ function type() {
 }
 
 function assertUniqueStoreMembers(store, newMemberKeys) {
-    if (!ngDevMode) {
+    if (typeof ngDevMode === 'undefined' || !ngDevMode) {
         return;
     }
     const storeMembers = {
@@ -236,9 +225,9 @@ function assertUniqueStoreMembers(store, newMemberKeys) {
         ...store.props,
         ...store.methods,
     };
-    const overriddenKeys = Object.keys(storeMembers).filter((memberKey) => newMemberKeys.includes(memberKey));
+    const overriddenKeys = Reflect.ownKeys(storeMembers).filter((memberKey) => newMemberKeys.includes(memberKey));
     if (overriddenKeys.length > 0) {
-        console.warn('@ngrx/signals: SignalStore members cannot be overridden.', 'Trying to override:', overriddenKeys.join(', '));
+        console.warn('@ngrx/signals: SignalStore members cannot be overridden.', 'Trying to override:', overriddenKeys.map((key) => String(key)).join(', '));
     }
 }
 
@@ -250,7 +239,7 @@ function withProps(propsFactory) {
             ...store.props,
             ...store.methods,
         });
-        assertUniqueStoreMembers(store, Object.keys(props));
+        assertUniqueStoreMembers(store, Reflect.ownKeys(props));
         return {
             ...store,
             props: { ...store.props, ...props },
@@ -262,6 +251,39 @@ function withComputed(signalsFactory) {
     return withProps(signalsFactory);
 }
 
+/**
+ * @description
+ * Allows passing properties, methods, or signals from a SignalStore
+ * to a feature.
+ *
+ * @usageNotes
+ * ```typescript
+ * signalStore(
+ *   withMethods((store) => ({
+ *     load(id: number): Observable<Entity> {
+ *       return of({ id, name: 'John' });
+ *     },
+ *   })),
+ *   withFeature(
+ *     // 👇 has full access to the store
+ *     (store) => withEntityLoader((id) => firstValueFrom(store.load(id)))
+ *   )
+ * );
+ * ```
+ *
+ * @param featureFactory function returning the actual feature
+ */
+function withFeature(featureFactory) {
+    return (store) => {
+        const storeForFactory = {
+            ...store['stateSignals'],
+            ...store['props'],
+            ...store['methods'],
+        };
+        return featureFactory(storeForFactory)(store);
+    };
+}
+
 function withHooks(hooksOrFactory) {
     return (store) => {
         const storeMembers = {
@@ -303,7 +325,7 @@ function withMethods(methodsFactory) {
             ...store.props,
             ...store.methods,
         });
-        assertUniqueStoreMembers(store, Object.keys(methods));
+        assertUniqueStoreMembers(store, Reflect.ownKeys(methods));
         return {
             ...store,
             methods: { ...store.methods, ...methods },
@@ -314,9 +336,9 @@ function withMethods(methodsFactory) {
 function withState(stateOrFactory) {
     return (store) => {
         const state = typeof stateOrFactory === 'function' ? stateOrFactory() : stateOrFactory;
-        const stateKeys = Object.keys(state);
+        const stateKeys = Reflect.ownKeys(state);
         assertUniqueStoreMembers(store, stateKeys);
-        store[STATE_SOURCE].update((currentState) => freezeInDevMode({
+        store[STATE_SOURCE].update((currentState) => ({
             ...currentState,
             ...state,
         }));
@@ -335,5 +357,5 @@ function withState(stateOrFactory) {
  * Generated bundle index. Do not edit.
  */
 
-export { deepComputed, getState, patchState, signalMethod, signalState, signalStore, signalStoreFeature, type, watchState, withComputed, withHooks, withMethods, withProps, withState };
+export { deepComputed, getState, isWritableStateSource, patchState, signalMethod, signalState, signalStore, signalStoreFeature, type, watchState, withComputed, withFeature, withHooks, withMethods, withProps, withState };
 //# sourceMappingURL=ngrx-signals.mjs.map