@webkrafters/react-eagleeye 0.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stephen Isienyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+<p align="center">
+	<img alt="Eagle Eye" height="150px" src="logo.png" width="250px" />
+</p>
+<p align="center">
+	<a href="https://typescriptlang.org">
+		<img alt="TypeScript" src="https://badgen.net/badge/icon/typescript?icon=typescript&label">
+	</a>
+	<a href="https://github.com/webKrafters/react-eagleeye.js/actions">
+		<img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/webKrafters/react-eagleeye.js/test.yml">
+	</a>
+	<a href="https://coveralls.io/github/webKrafters/react-eagleeye.js">
+		<img alt="coverage" src="https://img.shields.io/coveralls/github/webKrafters/react-eagleeye.js">
+	</a>
+	<img alt="NPM" src="https://img.shields.io/npm/l/@webkrafters/react-eagleeye">
+	<img alt="Maintenance" src="https://img.shields.io/maintenance/yes/2032">
+	<img alt="build size" src="https://img.shields.io/bundlephobia/minzip/@webkrafters/react-eagleeye?label=bundle%20size">
+	<a href="https://www.npmjs.com/package/@webKrafters/react-eagleeye">
+		<img alt="Downloads" src="https://img.shields.io/npm/dt/@webkrafters/react-eagleeye.svg">
+	</a>
+	<img alt="GitHub package.json version" src="https://img.shields.io/github/package-json/v/webKrafters/react-eagleeye.js">
+</p>
+
+# React Eagle Eye
+
+<table BORDER-COLOR="0a0" BORDER-WIDTH="2">
+    <td VALIGN="middle" ALIGN="center" FONT-WEIGHT="BOLD" COLOR="#333" HEIGHT="250px" width="1250px">
+		COMPATIBLE WITH REACT VERSIONS 19.2.0 AND BEYOND.<br />
+		FOR EARLIER VERSIONS OF REACT [v16.8.x TO v18.x.x], PLEASE USE THE<br />
+		<a href="https://www.npmjs.com/package/@webkrafters/react-eagleeye">React Observable Context</a>
+	</td>
+</table>
+<ul>
+	<li> Ready for use anywhere in the app. No Provider components needed.</li>
+	<li> Automatically prevents unnecessary cascading re-renders when used with the <a href="https://react-eagleeye.js.org/getting-started/#connect-usage"><code>connect</code></a> Stream API.</li>
+	<li> Auto-immutable update-friendly context. See <a href="https://react-eagleeye.js.org/concepts/store/setstate"><code>store.setState</code></a>.</li>
+	<li> A context bearing an observable consumer <a href="https://react-eagleeye.js.org/concepts/store">store</a>.</li>
+	<li> Recognizes <b>negative array indexing</b>. Please see <a href="https://react-eagleeye.js.org/concepts/property-path">Property Path</a> and <code>store.setState</code> <a href="https://react-eagleeye.js.org/concepts/store/setstate#indexing">Indexing</a>.</li>
+	<li> Only re-renders subscribing components (<a href="https://react-eagleeye.js.org/concepts/client">clients</a>) on context state changes.</li>
+	<li> Subscribing component decides which context state properties' changes to trigger its update.</li>
+	<li>OOB Support for framework-agnostic state sharing among applications. Simply create an <a href="https://auto-immutable.js.org/intro/">Auto Immutable</a> instance to pass around as the <code>value</code> argument for this or any <a href="https://eagleeye.js.org">Eagle Eye</a> based state manager instances.</li>
+</ul>
+
+**Name:** React Eagle Eye.
+
+**Usage:** Please see <b><a href="https://react-eagleeye.js.org/getting-started">Getting Started</a></b>.
+
+**Demo:** [Play with the app on codesandbox](https://codesandbox.io/s/github/webKrafters/react-eagleeye-app)\
+If sandbox fails to load app, please refresh dependencies on its lower left.
+
+**Install:**\
+npm install --save @webkrafters/react-eagleeye
+
+May also see <b><a href="https://react-eagleeye.js.org/history/features">What's Changed?</a></b>
+
+Full Documentation: **[react-eagleeye.js.org](https://react-eagleeye.js.org)**
+
+# License
+
+GPLv3

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { BaseType, ClearCommand, KeyType, MoveCommand, PushCommand, ReplaceCommand, SetCommand, SpliceCommand, TagCommand, TagType, UpdateStats, UpdatePayload, UpdatePayloadArray } from '@webkrafters/auto-immutable';
+export type { ArraySelector, Changes, Channel, Data, FullStateSelector, IStorage, IStore, Listener, ObjectSelector, Prehooks, ProviderProps, SelectorMap, State, Store, StoreInternal, StoreRef, Stream, Text, Unsubscribe } from '@webkrafters/eagleeye';
+import { SelectorMap, State, Store } from '@webkrafters/eagleeye';
+export { CLEAR_TAG, DELETE_TAG, FULL_STATE_SELECTOR, MOVE_TAG, NULL_SELECTOR, PUSH_TAG, REPLACE_TAG, SET_TAG, SPLICE_TAG, Tag, } from '@webkrafters/eagleeye';
+type InjectedProps<STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap> = {
+    [K in keyof Store<STATE, SELECTOR_MAP>]: Store<STATE, SELECTOR_MAP>[K];
+};
+export type ConnectProps<OWNPROPS extends OwnProps = IProps, STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap> = InjectedProps<STATE, SELECTOR_MAP> & Omit<OWNPROPS, keyof InjectedProps<STATE, SELECTOR_MAP>>;
+export type ExtractInjectedProps<STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap, ALL_PROPS extends OwnProps = OwnProps> = Omit<ALL_PROPS, keyof InjectedProps<STATE, SELECTOR_MAP>>;
+export interface IProps {
+}
+export type OwnProps = IProps & Record<any, any>;
+export { createContext as createEagleEye } from './main';

package/dist/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEagleEye = exports.Tag = exports.SPLICE_TAG = exports.SET_TAG = exports.REPLACE_TAG = exports.PUSH_TAG = exports.NULL_SELECTOR = exports.MOVE_TAG = exports.FULL_STATE_SELECTOR = exports.DELETE_TAG = exports.CLEAR_TAG = void 0;
+var eagleeye_1 = require("@webkrafters/eagleeye");
+Object.defineProperty(exports, "CLEAR_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.CLEAR_TAG;
+  }
+});
+Object.defineProperty(exports, "DELETE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.DELETE_TAG;
+  }
+});
+Object.defineProperty(exports, "FULL_STATE_SELECTOR", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.FULL_STATE_SELECTOR;
+  }
+});
+Object.defineProperty(exports, "MOVE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.MOVE_TAG;
+  }
+});
+Object.defineProperty(exports, "NULL_SELECTOR", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.NULL_SELECTOR;
+  }
+});
+Object.defineProperty(exports, "PUSH_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.PUSH_TAG;
+  }
+});
+Object.defineProperty(exports, "REPLACE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.REPLACE_TAG;
+  }
+});
+Object.defineProperty(exports, "SET_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.SET_TAG;
+  }
+});
+Object.defineProperty(exports, "SPLICE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.SPLICE_TAG;
+  }
+});
+Object.defineProperty(exports, "Tag", {
+  enumerable: true,
+  get: function get() {
+    return eagleeye_1.Tag;
+  }
+});
+var main_1 = require("./main");
+Object.defineProperty(exports, "createEagleEye", {
+  enumerable: true,
+  get: function get() {
+    return main_1.createContext;
+  }
+});

package/dist/main/index.d.ts

@@ -0,0 +1,22 @@
+import type { ElementType } from 'react';
+import type { ConnectProps, ExtractInjectedProps, SelectorMap, Store } from '..';
+import React from 'react';
+import { AutoImmutable, IStorage, Prehooks, State } from "@webkrafters/eagleeye";
+export declare class ObservableContext<T extends State> {
+    private consumer;
+    constructor(value?: T, prehooks?: Prehooks<T>, storage?: IStorage<T>);
+    constructor(value?: AutoImmutable<T>, prehooks?: Prehooks<T>, storage?: IStorage<T>);
+    get cache(): AutoImmutable<T>;
+    get closed(): boolean;
+    get connect(): <S extends SelectorMap>(selectorMap?: S) => <P extends ExtractInjectedProps<T, S>>(WrappedComponent: ElementType<ConnectProps<P, T, S>>) => React.NamedExoticComponent<P>;
+    get prehooks(): Prehooks<T>;
+    get storage(): IStorage<T>;
+    get store(): import("@webkrafters/eagleeye").StoreRef<T>;
+    get useStream(): <S extends SelectorMap>(selectorMap?: S) => Store<T, S>;
+    set prehooks(prehooks: Prehooks<T>);
+    set storage(storage: IStorage<T>);
+    private _connect;
+    dispose(): void;
+}
+export declare function createContext<T extends State>(value?: T, prehooks?: Prehooks<T>, storage?: IStorage<T>): ObservableContext<T>;
+export declare function createContext<T extends State>(value?: AutoImmutable<T>, prehooks?: Prehooks<T>, storage?: IStorage<T>): ObservableContext<T>;

package/dist/main/index.js

@@ -0,0 +1,217 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var __createBinding = void 0 && (void 0).__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = {
+      enumerable: true,
+      get: function get() {
+        return m[k];
+      }
+    };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+var __importStar = void 0 && (void 0).__importStar || function () {
+  var _ownKeys = function ownKeys(o) {
+    _ownKeys = Object.getOwnPropertyNames || function (o) {
+      var ar = [];
+      for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+      return ar;
+    };
+    return _ownKeys(o);
+  };
+  return function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k = _ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+}();
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObservableContext = void 0;
+exports.createContext = createContext;
+var lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+var lodash_isplainobject_1 = __importDefault(require("lodash.isplainobject"));
+var lodash_omit_1 = __importDefault(require("lodash.omit"));
+var react_1 = __importStar(require("react"));
+var eagleeye_1 = require("@webkrafters/eagleeye");
+var ObservableContext = /*#__PURE__*/function () {
+  function ObservableContext(value, prehooks, storage) {
+    var _this = this;
+    _classCallCheck(this, ObservableContext);
+    this._connect = function (selectorMap) {
+      var ctx = _this;
+      function connector(WrappedComponent) {
+        var useStream = ctx.useStream;
+        var Wrapped = !((0, lodash_isplainobject_1["default"])(WrappedComponent) && 'compare' in WrappedComponent) ? (0, react_1.memo)(WrappedComponent) : WrappedComponent;
+        var ConnectedComponent = (0, react_1.memo)(function (ownProps) {
+          var store = useStream(selectorMap);
+          return memoizeImmediateChildTree(react_1["default"].createElement(Wrapped, _objectSpread(_objectSpread({}, store), ownProps)));
+        });
+        ConnectedComponent.displayName = 'ObservableContext.Connected';
+        return ConnectedComponent;
+      }
+      return connector;
+    };
+    this.consumer = (0, eagleeye_1.createEagleEye)({
+      prehooks: prehooks,
+      storage: storage,
+      value: value
+    });
+  }
+  return _createClass(ObservableContext, [{
+    key: "cache",
+    get: function get() {
+      return this.consumer.cache;
+    }
+  }, {
+    key: "closed",
+    get: function get() {
+      return this.consumer.closed;
+    }
+  }, {
+    key: "connect",
+    get: function get() {
+      return this._connect;
+    }
+  }, {
+    key: "prehooks",
+    get: function get() {
+      return this.consumer.prehooks;
+    },
+    set: function set(prehooks) {
+      this.consumer.prehooks = prehooks;
+    }
+  }, {
+    key: "storage",
+    get: function get() {
+      return this.consumer.storage;
+    },
+    set: function set(storage) {
+      this.consumer.storage = storage;
+    }
+  }, {
+    key: "store",
+    get: function get() {
+      return this.consumer.store;
+    }
+  }, {
+    key: "useStream",
+    get: function get() {
+      var stream = this.consumer.stream;
+      return function (selectorMap) {
+        var _ref = (0, react_1.useState)(function () {
+            return stream(selectorMap);
+          }),
+          _ref2 = _slicedToArray(_ref, 1),
+          channel = _ref2[0];
+        var _ref3 = (0, react_1.useState)(function () {
+            return {
+              data: channel.data,
+              resetState: channel.resetState.bind(channel),
+              setState: channel.setState.bind(channel)
+            };
+          }),
+          _ref4 = _slicedToArray(_ref3, 2),
+          store = _ref4[0],
+          setStore = _ref4[1];
+        (0, react_1.useEffect)(function () {
+          channel.selectorMap = selectorMap;
+        }, [selectorMap]);
+        (0, react_1.useEffect)(function () {
+          channel.addListener('data-changed', function () {
+            return setStore(_objectSpread(_objectSpread({}, store), {}, {
+              data: channel.data
+            }));
+          });
+          return function () {
+            return channel.endStream();
+          };
+        }, []);
+        return store;
+      };
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.consumer.dispose();
+    }
+  }]);
+}();
+exports.ObservableContext = ObservableContext;
+var ChildMemo = function () {
+  var useNodeMemo = function useNodeMemo(node) {
+    var nodeRef = (0, react_1.useRef)(node);
+    if (!(0, lodash_isequal_1["default"])((0, lodash_omit_1["default"])(nodeRef.current, '_owner'), (0, lodash_omit_1["default"])(node, '_owner'))) {
+      nodeRef.current = node;
+    }
+    return nodeRef.current;
+  };
+  var ChildMemo = (0, react_1.memo)(function (_ref5) {
+    var child = _ref5.child;
+    return react_1["default"].createElement(react_1["default"].Fragment, null, child);
+  });
+  ChildMemo.displayName = 'ObservableContext.Provider.Internal.Guardian.ChildMemo';
+  var Guardian = function Guardian(_ref6) {
+    var child = _ref6.child;
+    return react_1["default"].createElement(ChildMemo, {
+      child: useNodeMemo(child)
+    });
+  };
+  Guardian.displayName = 'ObservableContext.Provider.Internal.Guardian';
+  return Guardian;
+}();
+function memoizeImmediateChildTree(children) {
+  return react_1.Children.map(children, function (_child) {
+    var _child2, _child$type$$$typeof, _child$props;
+    var child = _child;
+    if (!((_child2 = child) !== null && _child2 !== void 0 && _child2.type) || _typeof(child.type) === 'object' && ((_child$type$$$typeof = child.type.$$typeof) === null || _child$type$$$typeof === void 0 ? void 0 : _child$type$$$typeof.toString()) === 'Symbol(react.memo)') {
+      return child;
+    }
+    if ((_child$props = child.props) !== null && _child$props !== void 0 && _child$props.children) {
+      child = (0, react_1.cloneElement)(child, (0, lodash_omit_1["default"])(child.props, 'children'), memoizeImmediateChildTree(child.props.children));
+    }
+    return react_1["default"].createElement(ChildMemo, {
+      child: child
+    });
+  });
+}
+function createContext(value, prehooks, storage) {
+  return new ObservableContext(value, prehooks, storage);
+}

package/package.json

@@ -0,0 +1,132 @@
+{
+  "alias": "React Eagle Eye",
+  "author": "Stephen Isienyi <stephen.isienyi@webkrafting.com>",
+  "bugs": {
+    "url": "https://github.com/webKrafters/react-eagleeye.js/issues"
+  },
+  "contributors": [
+    "steveswork <stephen.isienyi@gmail.com> (https://github.com/steveswork)"
+  ],
+  "description": "React Eagle Eye - Reactive Streamable Observable Auto-Immutable Update-friendly State Management System for React 19+. Maintaining application wide state made easy.",
+  "devDependencies": {
+    "@babel/cli": "^7.17.0",
+    "@babel/core": "^7.20.5",
+    "@babel/node": "^7.12.10",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
+    "@babel/plugin-transform-runtime": "^7.17.0",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-react": "^7.18.6",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/jest": "^29.5.12",
+    "@types/jest-cli": "^24.3.0",
+    "@types/lodash.isempty": "^4.4.9",
+    "@types/lodash.isplainobject": "^4.0.9",
+    "@types/node": "^20.11.28",
+    "@types/react": "^19.2.9",
+    "@types/react-dom": "^19.2.3",
+    "@webkrafters/clone-total": "^1.0.1",
+    "@webkrafters/get-property": "^2.0.0",
+    "@webkrafters/path-dotize": "0.0.2",
+    "@webkrafters/timed-map": "^2.0.0",
+    "babel-loader": "^9.1.3",
+    "eslint": "^8.57.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jest": "^28.5.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-react": "^7.31.11",
+    "eslint-plugin-standard": "^5.0.0",
+    "jest": "^29.7.0",
+    "jest-cli": "^29.7.0",
+    "jest-environment-jsdom": "^30.3.0",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.clonedeepwith": "^4.5.0",
+    "lodash.isboolean": "^3.0.3",
+    "lodash.isempty": "^4.4.0",
+    "lodash.isequal": "^4.5.0",
+    "lodash.isinteger": "^4.0.4",
+    "lodash.isobject": "^3.0.2",
+    "lodash.isplainobject": "^4.0.6",
+    "lodash.omit": "^4.5.0",
+    "npm": "^4.0.6",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "react-performance-testing": "^2.0.0",
+    "setimmediate": "^1.0.5",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "files": [
+    "logo.png",
+    "dist"
+  ],
+  "homepage": "https://react-eagleeye.js.org",
+  "keywords": [
+    "connect",
+    "context",
+    "eagle eye",
+    "react eagle eye",
+    "eagleeye",
+    "react-eagleeye",
+    "hoc",
+    "hooks",
+    "observable",
+    "observable context",
+    "react",
+    "react context",
+    "react hooks",
+    "react observable conttext",
+    "react state",
+    "state",
+    "state management",
+    "state manager",
+    "useContext",
+    "useStream",
+    "stream",
+    "change stream"
+  ],
+  "license": "GPL-3.0-only",
+  "main": "dist/index.js",
+  "name": "@webkrafters/react-eagleeye",
+  "peerDependencies": {
+    "@types/react": ">= 19.2.9",
+    "@webkrafters/clone-total": ">= 1.0.1",
+    "@webkrafters/get-property": ">= 1.0.1",
+    "@webkrafters/path-dotize": ">= 0.0.2",
+    "@webkrafters/timed-map": "^2.0.0",
+    "lodash.clonedeep": ">= 0.1.0",
+    "lodash.clonedeepwith": ">= 0.1.0",
+    "lodash.isboolean": ">= 0.1.0",
+    "lodash.isempty": ">= 0.1.0",
+    "lodash.isequal": ">= 0.1.0",
+    "lodash.isinteger": ">= 0.1.0",
+    "lodash.isobject": ">= 0.1.0",
+    "lodash.isplainobject": ">= 0.8.0",
+    "lodash.omit": ">= 0.1.0",
+    "react": ">= 19.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webKrafters/react-eagleeye.js.git"
+  },
+  "scripts": {
+    "build": "eslint --fix && rm -rf dist && tsc && babel dist -d dist",
+    "test": "eslint --fix && jest --coverage --updateSnapshot",
+    "test:clean": "jest --clearCache",
+    "test:core": "jest --updateSnapshot",
+    "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
+  },
+  "types": "dist/index.d.ts",
+  "version": "0.0.9",
+  "dependencies": {
+    "@webkrafters/eagleeye": "^1.0.5"
+  }
+}