@solid-primitives/deep 0.2.10 → 0.3.1

package/README.md

@@ -4,7 +4,6 @@
 
 # @solid-primitives/deep
 
-[![turborepo](https://img.shields.io/badge/built%20with-turborepo-cc00ff.svg?style=for-the-badge&logo=turborepo)](https://turborepo.org/)
 [![size](https://img.shields.io/bundlephobia/minzip/@solid-primitives/deep?style=for-the-badge&label=size)](https://bundlephobia.com/package/@solid-primitives/deep)
 [![version](https://img.shields.io/npm/v/@solid-primitives/deep?style=for-the-badge)](https://www.npmjs.com/package/@solid-primitives/deep)
 [![stage](https://img.shields.io/endpoint?style=for-the-badge&url=https%3A%2F%2Fraw.githubusercontent.com%2Fsolidjs-community%2Fsolid-primitives%2Fmain%2Fassets%2Fbadges%2Fstage-1.json)](https://github.com/solidjs-community/solid-primitives#contribution-process)

package/dist/index.d.ts

@@ -1,80 +1,3 @@
-import { Store } from 'solid-js/store';
-
-/**
- * Tracks all properties of a {@link store} by iterating over them recursively.
- *
- * @param store reactive store dependency
- * @returns same {@link store} that was passed in
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackDeep
- *
- * @example
- * ```ts
- * createEffect(on(
- *   () => trackDeep(store),
- *   () => {
- *     // this effect will run when any property of store changes
- *   }
- * ));
- * ```
- */
-declare function trackDeep<T extends Store<object>>(store: T): T;
-/**
- * @deprecated Renamed to {@link trackDeep}
- */
-declare const deepTrack: typeof trackDeep;
-
-/**
- * Tracks all nested changes to passed {@link store}.
- *
- * @param store a reactive store proxy
- * @returns same {@link store} that was passed in
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackStore
- *
- * @example
- * ```ts
- * createEffect(on(
- *   () => trackStore(store),
- *   () => {
- *     // this effect will run when any property of store changes
- *   }
- * ));
- * ```
- */
-declare function trackStore<T extends object>(store: Store<T>): T;
-
-type Static<T = unknown> = {
-    [K in number | string]: T;
-} | T[];
-type AllNestedObjects<T> = T extends Static<infer U> ? AllNestedObjects<U> | T : never;
-type NestedUpdate<T> = {
-    path: (string | number)[];
-    value: AllNestedObjects<T>;
-};
-/**
- * Creates a function for tracking and capturing updates to a {@link store}.
- *
- * Each execution of the returned function will return an array of updates to the store since the last execution.
- *
- * @param store - The store to track.
- * @returns A function that returns an array of updates to the store since the last execution.
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#captureStoreUpdates
- *
- * @example
- * ```ts
- * const [state, setState] = createStore({ todos: [] });
- *
- * const getDelta = captureStoreUpdates(state);
- *
- * getDelta(); // [{ path: [], value: { todos: [] } }]
- *
- * setState("todos", ["foo"]);
- *
- * getDelta(); // [{ path: ["todos"], value: ["foo"] }]
- * ```
- */
-declare function captureStoreUpdates<T extends Static>(store: T): () => NestedUpdate<T>[];
-
-export { type AllNestedObjects, type NestedUpdate, captureStoreUpdates, deepTrack, trackDeep, trackStore };
+export * from "./track-deep.js";
+export * from "./track-store.js";
+export * from "./store-updates.js";

package/dist/index.js

@@ -1,143 +1,3 @@
-import { $PROXY, $TRACK, createRoot, createSignal, createMemo, untrack } from 'solid-js';
-import { unwrap } from 'solid-js/store';
-import { createLazyMemo } from '@solid-primitives/memo';
-import { isServer, isDev } from 'solid-js/web';
-
-// src/track-deep.ts
-function trackDeep(store) {
-  traverse(store, /* @__PURE__ */ new Set());
-  return store;
-}
-function traverse(value, seen) {
-  let isArray;
-  let proto;
-  if (value != null && typeof value === "object" && !seen.has(value) && ((isArray = Array.isArray(value)) || value[$PROXY] || !(proto = Object.getPrototypeOf(value)) || proto === Object.prototype)) {
-    seen.add(value);
-    for (const child of isArray ? value : Object.values(value)) traverse(child, seen);
-  }
-}
-var deepTrack = trackDeep;
-var EQUALS_FALSE = { equals: false };
-var TrackStoreCache = /* @__PURE__ */ new WeakMap();
-var TrackVersion = 0;
-function getTrackStoreNode(node) {
-  let track = TrackStoreCache.get(node);
-  if (!track) {
-    createRoot(() => {
-      const unwrapped = unwrap(node);
-      let is_reading = false;
-      let is_stale = true;
-      let version = 0;
-      const [signal, trigger] = createSignal(void 0, EQUALS_FALSE);
-      const memo = createMemo(
-        () => {
-          if (is_reading) {
-            node[$TRACK];
-            for (const [key, child] of Object.entries(unwrapped)) {
-              let childNode;
-              if (child != null && typeof child === "object" && ((childNode = child[$PROXY]) || $TRACK in (childNode = untrack(() => node[key])))) {
-                getTrackStoreNode(childNode)?.();
-              }
-            }
-          } else {
-            signal();
-            is_stale = true;
-          }
-        },
-        void 0,
-        EQUALS_FALSE
-      );
-      track = () => {
-        is_reading = true;
-        if (is_stale) {
-          trigger();
-          is_stale = false;
-        }
-        const already_tracked = version === TrackVersion;
-        version = TrackVersion;
-        already_tracked || memo();
-        is_reading = false;
-      };
-      TrackStoreCache.set(node, track);
-    });
-  }
-  return track;
-}
-function trackStore(store) {
-  TrackVersion++;
-  $TRACK in store && getTrackStoreNode(store)?.();
-  return store;
-}
-function* entries(obj) {
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < obj.length; i++) {
-      yield [i, obj[i]];
-    }
-  } else {
-    yield* Object.entries(obj)[Symbol.iterator]();
-  }
-}
-var StoreNodeChildrenCache = /* @__PURE__ */ new WeakMap();
-function getStoreNodechildren(node) {
-  let signal = StoreNodeChildrenCache.get(node);
-  if (!signal) {
-    const unwrapped = unwrap(node), isArray = Array.isArray(unwrapped);
-    signal = createRoot(
-      () => createLazyMemo(() => {
-        node[$TRACK];
-        const children = isArray ? [] : {};
-        for (const [key, child] of entries(unwrapped)) {
-          let childNode;
-          if (child != null && typeof child === "object" && ((childNode = child[$PROXY]) || (childNode = untrack(() => node[key])) && $TRACK in childNode)) {
-            children[key] = childNode;
-          }
-        }
-        return children;
-      })
-    );
-    StoreNodeChildrenCache.set(node, signal);
-  }
-  return signal();
-}
-var CurrentUpdates;
-var SeenNodes;
-function newCacheNode(children) {
-  const record = { ...children };
-  for (const [key, node] of entries(children)) {
-    if (SeenNodes.has(node)) continue;
-    SeenNodes.add(node);
-    record[key] = newCacheNode(getStoreNodechildren(node));
-  }
-  return { children, record };
-}
-function compareStoreWithCache(node, parent, key, path) {
-  if (SeenNodes.has(node)) return;
-  SeenNodes.add(node);
-  const cacheNode = parent[key], children = getStoreNodechildren(node);
-  if (cacheNode && children === cacheNode.children) {
-    for (const [key2, child] of entries(children)) {
-      compareStoreWithCache(child, cacheNode.record, key2, [...path, key2]);
-    }
-  } else {
-    parent[key] = newCacheNode(children);
-    CurrentUpdates.push({ path, value: node });
-  }
-}
-function captureStoreUpdates(store) {
-  if (isServer || !($TRACK in store)) {
-    if (isDev) {
-      console.warn("createStoreDelta expects a store, got", store);
-    }
-    let init = true;
-    return () => init ? (init = false, [{ path: [], value: store }]) : [];
-  }
-  const cache = {};
-  return () => {
-    CurrentUpdates = [];
-    SeenNodes = /* @__PURE__ */ new WeakSet();
-    compareStoreWithCache(store, cache, "root", []);
-    return CurrentUpdates;
-  };
-}
-
-export { captureStoreUpdates, deepTrack, trackDeep, trackStore };
+export * from "./track-deep.js";
+export * from "./track-store.js";
+export * from "./store-updates.js";

package/dist/store-updates.d.ts

@@ -0,0 +1,33 @@
+type Static<T = unknown> = {
+    [K in number | string]: T;
+} | T[];
+export type AllNestedObjects<T> = T extends Static<infer U> ? AllNestedObjects<U> | T : never;
+export type NestedUpdate<T> = {
+    path: (string | number)[];
+    value: AllNestedObjects<T>;
+};
+/**
+ * Creates a function for tracking and capturing updates to a {@link store}.
+ *
+ * Each execution of the returned function will return an array of updates to the store since the last execution.
+ *
+ * @param store - The store to track.
+ * @returns A function that returns an array of updates to the store since the last execution.
+ *
+ * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#captureStoreUpdates
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ todos: [] });
+ *
+ * const getDelta = captureStoreUpdates(state);
+ *
+ * getDelta(); // [{ path: [], value: { todos: [] } }]
+ *
+ * setState("todos", ["foo"]);
+ *
+ * getDelta(); // [{ path: ["todos"], value: ["foo"] }]
+ * ```
+ */
+export declare function captureStoreUpdates<T extends Static>(store: T): () => NestedUpdate<T>[];
+export {};

package/dist/store-updates.js

@@ -0,0 +1,109 @@
+import { createLazyMemo } from "@solid-primitives/memo";
+import { $PROXY, $TRACK, createRoot, untrack } from "solid-js";
+import { unwrap } from "solid-js/store";
+import { isDev, isServer } from "solid-js/web";
+function* entries(obj) {
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            // @ts-ignore
+            yield [i, obj[i]];
+        }
+    }
+    else {
+        // @ts-ignore
+        yield* Object.entries(obj)[Symbol.iterator]();
+    }
+}
+const StoreNodeChildrenCache = new WeakMap();
+function getStoreNodechildren(node) {
+    let signal = StoreNodeChildrenCache.get(node);
+    if (!signal) {
+        const unwrapped = unwrap(node), isArray = Array.isArray(unwrapped);
+        signal = createRoot(() => createLazyMemo(() => {
+            node[$TRACK];
+            const children = isArray ? [] : {};
+            for (const [key, child] of entries(unwrapped)) {
+                let childNode;
+                if (child != null &&
+                    typeof child === "object" &&
+                    ((childNode = child[$PROXY]) ||
+                        ((childNode = untrack(() => node[key])) && $TRACK in childNode))) {
+                    children[key] = childNode;
+                }
+            }
+            return children;
+        }));
+        StoreNodeChildrenCache.set(node, signal);
+    }
+    return signal();
+}
+let CurrentUpdates;
+let SeenNodes;
+function newCacheNode(children) {
+    const record = { ...children };
+    for (const [key, node] of entries(children)) {
+        if (SeenNodes.has(node))
+            continue;
+        SeenNodes.add(node);
+        record[key] = newCacheNode(getStoreNodechildren(node));
+    }
+    return { children, record };
+}
+function compareStoreWithCache(node, parent, key, path) {
+    if (SeenNodes.has(node))
+        return;
+    SeenNodes.add(node);
+    const cacheNode = parent[key], children = getStoreNodechildren(node);
+    if (cacheNode && children === cacheNode.children) {
+        for (const [key, child] of entries(children)) {
+            compareStoreWithCache(child, cacheNode.record, key, [...path, key]);
+        }
+    }
+    else {
+        parent[key] = newCacheNode(children);
+        CurrentUpdates.push({ path, value: node });
+    }
+}
+/**
+ * Creates a function for tracking and capturing updates to a {@link store}.
+ *
+ * Each execution of the returned function will return an array of updates to the store since the last execution.
+ *
+ * @param store - The store to track.
+ * @returns A function that returns an array of updates to the store since the last execution.
+ *
+ * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#captureStoreUpdates
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ todos: [] });
+ *
+ * const getDelta = captureStoreUpdates(state);
+ *
+ * getDelta(); // [{ path: [], value: { todos: [] } }]
+ *
+ * setState("todos", ["foo"]);
+ *
+ * getDelta(); // [{ path: ["todos"], value: ["foo"] }]
+ * ```
+ */
+export function captureStoreUpdates(store) {
+    // on the server you cannot check if the passed object is a store
+    // so we just return the whole store always
+    if (isServer || !($TRACK in store)) {
+        if (isDev) {
+            // eslint-disable-next-line no-console
+            console.warn("createStoreDelta expects a store, got", store);
+        }
+        let init = true;
+        return () => (init ? ((init = false), [{ path: [], value: store }]) : []);
+    }
+    const cache = {};
+    return () => {
+        // set globals before each cycle
+        CurrentUpdates = [];
+        SeenNodes = new WeakSet();
+        compareStoreWithCache(store, cache, "root", []);
+        return CurrentUpdates;
+    };
+}

package/dist/track-deep.d.ts

@@ -0,0 +1,25 @@
+import { Store } from "solid-js/store";
+/**
+ * Tracks all properties of a {@link store} by iterating over them recursively.
+ *
+ * @param store reactive store dependency
+ * @returns same {@link store} that was passed in
+ *
+ * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackDeep
+ *
+ * @example
+ * ```ts
+ * createEffect(on(
+ *   () => trackDeep(store),
+ *   () => {
+ *     // this effect will run when any property of store changes
+ *   }
+ * ));
+ * ```
+ */
+declare function trackDeep<T extends Store<object>>(store: T): T;
+/**
+ * @deprecated Renamed to {@link trackDeep}
+ */
+declare const deepTrack: typeof trackDeep;
+export { trackDeep, deepTrack };

package/dist/track-deep.js

@@ -0,0 +1,44 @@
+import { $PROXY } from "solid-js";
+/**
+ * Tracks all properties of a {@link store} by iterating over them recursively.
+ *
+ * @param store reactive store dependency
+ * @returns same {@link store} that was passed in
+ *
+ * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackDeep
+ *
+ * @example
+ * ```ts
+ * createEffect(on(
+ *   () => trackDeep(store),
+ *   () => {
+ *     // this effect will run when any property of store changes
+ *   }
+ * ));
+ * ```
+ */
+function trackDeep(store) {
+    traverse(store, new Set());
+    return store;
+}
+function traverse(value, seen) {
+    let isArray;
+    let proto;
+    // check the same conditions as in `isWrappable` from `/packages/solid/store/src/store.ts`
+    if (value != null &&
+        typeof value === "object" &&
+        !seen.has(value) &&
+        ((isArray = Array.isArray(value)) ||
+            value[$PROXY] ||
+            !(proto = Object.getPrototypeOf(value)) ||
+            proto === Object.prototype)) {
+        seen.add(value);
+        for (const child of isArray ? value : Object.values(value))
+            traverse(child, seen);
+    }
+}
+/**
+ * @deprecated Renamed to {@link trackDeep}
+ */
+const deepTrack = trackDeep;
+export { trackDeep, deepTrack };

package/dist/track-store.d.ts

@@ -0,0 +1,21 @@
+import { Store } from "solid-js/store";
+/**
+ * Tracks all nested changes to passed {@link store}.
+ *
+ * @param store a reactive store proxy
+ * @returns same {@link store} that was passed in
+ *
+ * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackStore
+ *
+ * @example
+ * ```ts
+ * createEffect(on(
+ *   () => trackStore(store),
+ *   () => {
+ *     // this effect will run when any property of store changes
+ *   }
+ * ));
+ * ```
+ */
+declare function trackStore<T extends object>(store: Store<T>): T;
+export { trackStore };

package/dist/track-store.js

@@ -0,0 +1,75 @@
+import { $PROXY, $TRACK, createMemo, createRoot, createSignal, untrack } from "solid-js";
+import { unwrap } from "solid-js/store";
+const EQUALS_FALSE = { equals: false };
+const TrackStoreCache = new WeakMap();
+// for preventing the same object to be visited multiple times in the same trackStore call
+let TrackVersion = 0;
+function getTrackStoreNode(node) {
+    let track = TrackStoreCache.get(node);
+    if (!track) {
+        createRoot(() => {
+            const unwrapped = unwrap(node);
+            // custom lazy memo to support circular references
+            // maybe it won't be needed in solid 2.0
+            let is_reading = false;
+            let is_stale = true;
+            let version = 0;
+            const [signal, trigger] = createSignal(undefined, EQUALS_FALSE);
+            const memo = createMemo(() => {
+                if (is_reading) {
+                    node[$TRACK]; // shallow track store node
+                    // track each child node
+                    for (const [key, child] of Object.entries(unwrapped)) {
+                        let childNode;
+                        if (child != null &&
+                            typeof child === "object" &&
+                            ((childNode = child[$PROXY]) || $TRACK in (childNode = untrack(() => node[key])))) {
+                            getTrackStoreNode(childNode)?.();
+                        }
+                    }
+                }
+                else {
+                    signal();
+                    is_stale = true;
+                }
+            }, undefined, EQUALS_FALSE);
+            track = () => {
+                is_reading = true;
+                if (is_stale) {
+                    trigger();
+                    is_stale = false;
+                }
+                const already_tracked = version === TrackVersion;
+                version = TrackVersion;
+                already_tracked || memo();
+                is_reading = false;
+            };
+            TrackStoreCache.set(node, track);
+        });
+    }
+    return track;
+}
+/**
+ * Tracks all nested changes to passed {@link store}.
+ *
+ * @param store a reactive store proxy
+ * @returns same {@link store} that was passed in
+ *
+ * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackStore
+ *
+ * @example
+ * ```ts
+ * createEffect(on(
+ *   () => trackStore(store),
+ *   () => {
+ *     // this effect will run when any property of store changes
+ *   }
+ * ));
+ * ```
+ */
+function trackStore(store) {
+    TrackVersion++;
+    $TRACK in store && getTrackStoreNode(store)?.();
+    return store;
+}
+export { trackStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solid-primitives/deep",
-  "version": "0.2.10",
+  "version": "0.3.1",
   "description": "Primitives for tracking and observing nested reactive objects in Solid.",
   "author": "Samuel Burbano <me@iosamuel.dev>",
   "contributors": [
@@ -39,23 +39,19 @@
     "dist"
   ],
   "type": "module",
-  "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "browser": {},
   "types": "./dist/index.d.ts",
   "exports": {
+    "@solid-primitives/source": "./src/index.ts",
     "import": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    },
-    "require": {
-      "types": "./dist/index.d.cts",
-      "default": "./dist/index.cjs"
     }
   },
   "typesVersions": {},
   "dependencies": {
-    "@solid-primitives/memo": "^1.3.10"
+    "@solid-primitives/memo": "^1.4.1"
   },
   "peerDependencies": {
     "solid-js": "^1.6.12"

package/dist/index.cjs

@@ -1,147 +0,0 @@
-'use strict';
-
-var solidJs = require('solid-js');
-var store = require('solid-js/store');
-var memo = require('@solid-primitives/memo');
-var web = require('solid-js/web');
-
-// src/track-deep.ts
-function trackDeep(store) {
-  traverse(store, /* @__PURE__ */ new Set());
-  return store;
-}
-function traverse(value, seen) {
-  let isArray;
-  let proto;
-  if (value != null && typeof value === "object" && !seen.has(value) && ((isArray = Array.isArray(value)) || value[solidJs.$PROXY] || !(proto = Object.getPrototypeOf(value)) || proto === Object.prototype)) {
-    seen.add(value);
-    for (const child of isArray ? value : Object.values(value)) traverse(child, seen);
-  }
-}
-exports.deepTrack = trackDeep;
-var EQUALS_FALSE = { equals: false };
-var TrackStoreCache = /* @__PURE__ */ new WeakMap();
-var TrackVersion = 0;
-function getTrackStoreNode(node) {
-  let track = TrackStoreCache.get(node);
-  if (!track) {
-    solidJs.createRoot(() => {
-      const unwrapped = store.unwrap(node);
-      let is_reading = false;
-      let is_stale = true;
-      let version = 0;
-      const [signal, trigger] = solidJs.createSignal(void 0, EQUALS_FALSE);
-      const memo = solidJs.createMemo(
-        () => {
-          if (is_reading) {
-            node[solidJs.$TRACK];
-            for (const [key, child] of Object.entries(unwrapped)) {
-              let childNode;
-              if (child != null && typeof child === "object" && ((childNode = child[solidJs.$PROXY]) || solidJs.$TRACK in (childNode = solidJs.untrack(() => node[key])))) {
-                getTrackStoreNode(childNode)?.();
-              }
-            }
-          } else {
-            signal();
-            is_stale = true;
-          }
-        },
-        void 0,
-        EQUALS_FALSE
-      );
-      track = () => {
-        is_reading = true;
-        if (is_stale) {
-          trigger();
-          is_stale = false;
-        }
-        const already_tracked = version === TrackVersion;
-        version = TrackVersion;
-        already_tracked || memo();
-        is_reading = false;
-      };
-      TrackStoreCache.set(node, track);
-    });
-  }
-  return track;
-}
-function trackStore(store) {
-  TrackVersion++;
-  solidJs.$TRACK in store && getTrackStoreNode(store)?.();
-  return store;
-}
-function* entries(obj) {
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < obj.length; i++) {
-      yield [i, obj[i]];
-    }
-  } else {
-    yield* Object.entries(obj)[Symbol.iterator]();
-  }
-}
-var StoreNodeChildrenCache = /* @__PURE__ */ new WeakMap();
-function getStoreNodechildren(node) {
-  let signal = StoreNodeChildrenCache.get(node);
-  if (!signal) {
-    const unwrapped = store.unwrap(node), isArray = Array.isArray(unwrapped);
-    signal = solidJs.createRoot(
-      () => memo.createLazyMemo(() => {
-        node[solidJs.$TRACK];
-        const children = isArray ? [] : {};
-        for (const [key, child] of entries(unwrapped)) {
-          let childNode;
-          if (child != null && typeof child === "object" && ((childNode = child[solidJs.$PROXY]) || (childNode = solidJs.untrack(() => node[key])) && solidJs.$TRACK in childNode)) {
-            children[key] = childNode;
-          }
-        }
-        return children;
-      })
-    );
-    StoreNodeChildrenCache.set(node, signal);
-  }
-  return signal();
-}
-var CurrentUpdates;
-var SeenNodes;
-function newCacheNode(children) {
-  const record = { ...children };
-  for (const [key, node] of entries(children)) {
-    if (SeenNodes.has(node)) continue;
-    SeenNodes.add(node);
-    record[key] = newCacheNode(getStoreNodechildren(node));
-  }
-  return { children, record };
-}
-function compareStoreWithCache(node, parent, key, path) {
-  if (SeenNodes.has(node)) return;
-  SeenNodes.add(node);
-  const cacheNode = parent[key], children = getStoreNodechildren(node);
-  if (cacheNode && children === cacheNode.children) {
-    for (const [key2, child] of entries(children)) {
-      compareStoreWithCache(child, cacheNode.record, key2, [...path, key2]);
-    }
-  } else {
-    parent[key] = newCacheNode(children);
-    CurrentUpdates.push({ path, value: node });
-  }
-}
-function captureStoreUpdates(store) {
-  if (web.isServer || !(solidJs.$TRACK in store)) {
-    if (web.isDev) {
-      console.warn("createStoreDelta expects a store, got", store);
-    }
-    let init = true;
-    return () => init ? (init = false, [{ path: [], value: store }]) : [];
-  }
-  const cache = {};
-  return () => {
-    CurrentUpdates = [];
-    SeenNodes = /* @__PURE__ */ new WeakSet();
-    compareStoreWithCache(store, cache, "root", []);
-    return CurrentUpdates;
-  };
-}
-
-exports.captureStoreUpdates = captureStoreUpdates;
-exports.trackDeep = trackDeep;
-exports.trackStore = trackStore;

package/dist/index.d.cts

@@ -1,80 +0,0 @@
-import { Store } from 'solid-js/store';
-
-/**
- * Tracks all properties of a {@link store} by iterating over them recursively.
- *
- * @param store reactive store dependency
- * @returns same {@link store} that was passed in
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackDeep
- *
- * @example
- * ```ts
- * createEffect(on(
- *   () => trackDeep(store),
- *   () => {
- *     // this effect will run when any property of store changes
- *   }
- * ));
- * ```
- */
-declare function trackDeep<T extends Store<object>>(store: T): T;
-/**
- * @deprecated Renamed to {@link trackDeep}
- */
-declare const deepTrack: typeof trackDeep;
-
-/**
- * Tracks all nested changes to passed {@link store}.
- *
- * @param store a reactive store proxy
- * @returns same {@link store} that was passed in
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#trackStore
- *
- * @example
- * ```ts
- * createEffect(on(
- *   () => trackStore(store),
- *   () => {
- *     // this effect will run when any property of store changes
- *   }
- * ));
- * ```
- */
-declare function trackStore<T extends object>(store: Store<T>): T;
-
-type Static<T = unknown> = {
-    [K in number | string]: T;
-} | T[];
-type AllNestedObjects<T> = T extends Static<infer U> ? AllNestedObjects<U> | T : never;
-type NestedUpdate<T> = {
-    path: (string | number)[];
-    value: AllNestedObjects<T>;
-};
-/**
- * Creates a function for tracking and capturing updates to a {@link store}.
- *
- * Each execution of the returned function will return an array of updates to the store since the last execution.
- *
- * @param store - The store to track.
- * @returns A function that returns an array of updates to the store since the last execution.
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/deep#captureStoreUpdates
- *
- * @example
- * ```ts
- * const [state, setState] = createStore({ todos: [] });
- *
- * const getDelta = captureStoreUpdates(state);
- *
- * getDelta(); // [{ path: [], value: { todos: [] } }]
- *
- * setState("todos", ["foo"]);
- *
- * getDelta(); // [{ path: ["todos"], value: ["foo"] }]
- * ```
- */
-declare function captureStoreUpdates<T extends Static>(store: T): () => NestedUpdate<T>[];
-
-export { type AllNestedObjects, type NestedUpdate, captureStoreUpdates, deepTrack, trackDeep, trackStore };