@webkrafters/react-eagleeye 1.0.5 → 1.1.0-alpha

package/dist/index.js

@@ -3,72 +3,71 @@
 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;
+    return _eagleeye.CLEAR_TAG;
   }
 });
 Object.defineProperty(exports, "DELETE_TAG", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.DELETE_TAG;
+    return _eagleeye.DELETE_TAG;
   }
 });
 Object.defineProperty(exports, "FULL_STATE_SELECTOR", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.FULL_STATE_SELECTOR;
+    return _eagleeye.FULL_STATE_SELECTOR;
   }
 });
 Object.defineProperty(exports, "MOVE_TAG", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.MOVE_TAG;
+    return _eagleeye.MOVE_TAG;
   }
 });
 Object.defineProperty(exports, "NULL_SELECTOR", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.NULL_SELECTOR;
+    return _eagleeye.NULL_SELECTOR;
   }
 });
 Object.defineProperty(exports, "PUSH_TAG", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.PUSH_TAG;
+    return _eagleeye.PUSH_TAG;
   }
 });
 Object.defineProperty(exports, "REPLACE_TAG", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.REPLACE_TAG;
+    return _eagleeye.REPLACE_TAG;
   }
 });
 Object.defineProperty(exports, "SET_TAG", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.SET_TAG;
+    return _eagleeye.SET_TAG;
   }
 });
 Object.defineProperty(exports, "SPLICE_TAG", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.SPLICE_TAG;
+    return _eagleeye.SPLICE_TAG;
   }
 });
 Object.defineProperty(exports, "Tag", {
   enumerable: true,
   get: function get() {
-    return eagleeye_1.Tag;
+    return _eagleeye.Tag;
   }
 });
-var main_1 = require("./main");
 Object.defineProperty(exports, "createEagleEye", {
   enumerable: true,
   get: function get() {
-    return main_1.createContext;
+    return _main.createContext;
   }
-});
+});
+var _eagleeye = require("@webkrafters/eagleeye");
+var _main = require("./main");

package/dist/main/index.d.ts

@@ -1,22 +1,26 @@
 import type { ElementType } from 'react';
-import type { ConnectProps, ExtractInjectedProps, SelectorMap, Store } from '..';
+import type { Channel, 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;
+export declare abstract class AbstractObservable<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 stream(): import("@webkrafters/eagleeye").BaseStream<T>;
     get cache(): AutoImmutable<T>;
     get closed(): boolean;
-    get connect(): <const 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(): <const S extends SelectorMap>(selectorMap?: S) => Store<T, S>;
     set prehooks(prehooks: Prehooks<T>);
     set storage(storage: IStorage<T>);
-    private _connect;
     dispose(): void;
 }
+export declare class ObservableContext<T extends State> extends AbstractObservable<T> {
+    get connect(): <const S extends SelectorMap>(selectorMap?: S) => <P extends ExtractInjectedProps<T, S>>(WrappedComponent: ElementType<ConnectProps<P, T, S>>) => React.NamedExoticComponent<P>;
+    get useStream(): <const S extends SelectorMap>(selectorMap?: S) => Store<T, S>;
+    private _connect;
+}
+export declare function makeStore<T extends State, S extends SelectorMap>(channel: Channel<T, S>): Store<T, S>;
 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

@@ -1,5 +1,18 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObservableContext = exports.AbstractObservable = void 0;
+exports.createContext = createContext;
+exports.makeStore = makeStore;
+var _jsxRuntime = require("react/jsx-runtime");
+var _lodash = _interopRequireDefault(require("lodash.isequal"));
+var _lodash2 = _interopRequireDefault(require("lodash.isplainobject"));
+var _lodash3 = _interopRequireDefault(require("lodash.omit"));
+var _react = require("react");
+var _eagleeye = require("@webkrafters/eagleeye");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 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."); }
@@ -9,205 +22,184 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 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 _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(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 _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 _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)({
+var AbstractObservable = exports.AbstractObservable = /*#__PURE__*/function () {
+  function AbstractObservable(value, prehooks, storage) {
+    _classCallCheck(this, AbstractObservable);
+    _defineProperty(this, "_consumer", void 0);
+    this._consumer = (0, _eagleeye.createEagleEye)({
       prehooks: prehooks,
       storage: storage,
       value: value
     });
   }
-  return _createClass(ObservableContext, [{
-    key: "cache",
+  return _createClass(AbstractObservable, [{
+    key: "stream",
     get: function get() {
-      return this.consumer.cache;
+      return this._consumer.stream;
     }
   }, {
-    key: "closed",
+    key: "cache",
     get: function get() {
-      return this.consumer.closed;
+      return this._consumer.cache;
     }
   }, {
-    key: "connect",
+    key: "closed",
     get: function get() {
-      return this._connect;
+      return this._consumer.closed;
     }
   }, {
     key: "prehooks",
     get: function get() {
-      return this.consumer.prehooks;
+      return this._consumer.prehooks;
     },
     set: function set(prehooks) {
-      this.consumer.prehooks = prehooks;
+      this._consumer.prehooks = prehooks;
     }
   }, {
     key: "storage",
     get: function get() {
-      return this.consumer.storage;
+      return this._consumer.storage;
     },
     set: function set(storage) {
-      this.consumer.storage = storage;
+      this._consumer.storage = storage;
     }
   }, {
     key: "store",
     get: function get() {
-      return this.consumer.store;
+      return this._consumer.store;
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._consumer.dispose();
+    }
+  }]);
+}();
+var ObservableContext = exports.ObservableContext = /*#__PURE__*/function (_AbstractObservable2) {
+  function ObservableContext() {
+    var _this;
+    _classCallCheck(this, ObservableContext);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, ObservableContext, [].concat(args));
+    _defineProperty(_this, "_connect", function (selectorMap) {
+      var ctx = _this;
+      function connector(WrappedComponent) {
+        var useStream = ctx.useStream;
+        var Wrapped = !((0, _lodash2["default"])(WrappedComponent) && 'compare' in WrappedComponent) ? /*#__PURE__*/(0, _react.memo)(WrappedComponent) : WrappedComponent;
+        var ConnectedComponent = /*#__PURE__*/(0, _react.memo)(function (ownProps) {
+          var store = useStream(selectorMap);
+          return memoizeImmediateChildTree((0, _jsxRuntime.jsx)(Wrapped, _objectSpread(_objectSpread({}, store), ownProps)));
+        });
+        ConnectedComponent.displayName = 'ObservableContext.Connected';
+        return ConnectedComponent;
+      }
+      return connector;
+    });
+    return _this;
+  }
+  _inherits(ObservableContext, _AbstractObservable2);
+  return _createClass(ObservableContext, [{
+    key: "connect",
+    get: function get() {
+      return this._connect;
     }
   }, {
     key: "useStream",
     get: function get() {
-      var stream = this.consumer.stream;
+      var stream = this.stream;
       return function (selectorMap) {
-        var _ref = (0, react_1.useState)(function () {
+        var strictMode = (0, _react.useRef)(true);
+        var _useState = (0, _react.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)
-            };
+          _useState2 = _slicedToArray(_useState, 1),
+          channel = _useState2[0];
+        var _useState3 = (0, _react.useState)(function () {
+            return makeStore(channel);
           }),
-          _ref4 = _slicedToArray(_ref3, 2),
-          store = _ref4[0],
-          setStore = _ref4[1];
-        (0, react_1.useEffect)(function () {
+          _useState4 = _slicedToArray(_useState3, 2),
+          store = _useState4[0],
+          setStore = _useState4[1];
+        (0, _react.useEffect)(function () {
           channel.selectorMap = selectorMap;
         }, [selectorMap]);
-        (0, react_1.useEffect)(function () {
+        (0, _react.useEffect)(function () {
+          if (!strictMode.current) {
+            return;
+          }
           channel.addListener('data-changed', function () {
             return setStore(_objectSpread(_objectSpread({}, store), {}, {
               data: channel.data
             }));
           });
+          strictMode.current = false;
           return function () {
-            return channel.endStream();
+            channel.endStream();
+            strictMode.current = true;
           };
         }, []);
         return store;
       };
     }
-  }, {
-    key: "dispose",
-    value: function dispose() {
-      this.consumer.dispose();
-    }
   }]);
-}();
-exports.ObservableContext = ObservableContext;
+}(AbstractObservable);
 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'))) {
+    var nodeRef = (0, _react.useRef)(node);
+    if (!(0, _lodash["default"])((0, _lodash3["default"])(nodeRef.current, '_owner'), (0, _lodash3["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);
+  var ChildMemo = /*#__PURE__*/(0, _react.memo)(function (_ref) {
+    var child = _ref.child;
+    return (0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+      children: child
+    });
   });
   ChildMemo.displayName = 'ObservableContext.Provider.Internal.Guardian.ChildMemo';
-  var Guardian = function Guardian(_ref6) {
-    var child = _ref6.child;
-    return react_1["default"].createElement(ChildMemo, {
+  var Guardian = function Guardian(_ref2) {
+    var child = _ref2.child;
+    return (0, _jsxRuntime.jsx)(ChildMemo, {
       child: useNodeMemo(child)
     });
   };
   Guardian.displayName = 'ObservableContext.Provider.Internal.Guardian';
   return Guardian;
 }();
+function makeStore(channel) {
+  return {
+    data: channel.data,
+    resetState: channel.resetState.bind(channel),
+    setState: channel.setState.bind(channel)
+  };
+}
 function memoizeImmediateChildTree(children) {
-  return react_1.Children.map(children, function (_child) {
+  return _react.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));
+      child = /*#__PURE__*/(0, _react.cloneElement)(child, (0, _lodash3["default"])(child.props, 'children'), memoizeImmediateChildTree(child.props.children));
     }
-    return react_1["default"].createElement(ChildMemo, {
+    return (0, _jsxRuntime.jsx)(ChildMemo, {
       child: child
     });
   });

package/dist/main/universal/index.d.ts

@@ -0,0 +1,161 @@
+import { FC, RefObject, ComponentType, JSX } from 'react';
+import { AbstractObservable } from '..';
+import { Channel, type ProviderProps as BaseProviderProps, SelectorMap, State, Store } from '../../';
+export interface Address<ID extends string = string> {
+    targetId: ID;
+}
+export interface Point<T extends State = any, ID extends string = string> extends Address<ID> {
+    target: AbstractObservable<T>;
+}
+export type BaseProviderPropsRaw<T extends State> = {
+    value?: T;
+} & Pick<BaseProviderProps<T>, "prehooks" | "storage">;
+export interface IProviderProps<ID extends string = string> {
+    ref?: RefObject<Address<ID>>;
+}
+export interface RefProps<ID extends string = string> extends IProviderProps<ID> {
+    targetId: ID;
+}
+export interface ProviderProps<T extends State = any, ID extends string = string> extends IProviderProps<ID> {
+    observable?: AbstractObservable<T>;
+}
+export interface ProviderPropsRaw<T extends State = any, ID extends string = string> extends IProviderProps<ID> {
+    observableConfig?: BaseProviderProps<T>;
+}
+export interface ProviderPropsPrimitive<T extends State = any, ID extends string = string> extends IProviderProps<ID> {
+    observableConfig?: BaseProviderPropsRaw<T>;
+}
+type TemplateType<P> = P extends IProviderProps<infer U> ? U : never;
+type TemplateType2<T> = T extends AbstractObservable<infer U> ? U : never;
+export type WithChildren<P extends IProviderProps<TemplateType<P>>> = P & {
+    children?: React.ReactNode;
+};
+export interface ChannelEntry {
+    channel: WeakRef<Channel>;
+    numConnections: number;
+    useStore: () => Store;
+}
+export interface Entry {
+    channels: ChsResource<Channel>;
+    observable: WeakRef<AbstractObservable<any>>;
+}
+export interface Handle<W extends WeakKey> {
+    readonly descriptor: string;
+    readonly resource: W;
+}
+interface IResource<W extends WeakKey> {
+    acquire(desc: string, resource: W): Handle<W>;
+    createHandleFor(desc: string): Handle<W>;
+    getResourceAt(desc: string): W;
+}
+declare class ChsResource<W extends Channel> implements IResource<W> {
+    private _finalizer;
+    private _registry;
+    acquire(sMapHash: string, resource: W): {
+        readonly descriptor: string;
+        readonly isValid: boolean;
+        readonly resource: W;
+        readonly size: number;
+        readonly useStore: () => Store;
+        dec: () => void;
+        inc(): void;
+    };
+    createHandleFor(sMapHash: string): {
+        readonly descriptor: string;
+        readonly isValid: boolean;
+        readonly resource: W;
+        readonly size: number;
+        readonly useStore: () => Store;
+        dec: () => void;
+        inc(): void;
+    };
+    getResourceAt(sMapHash: string): W;
+    private finalize;
+}
+declare class ObsResource<W extends AbstractObservable<TemplateType2<W>>> implements IResource<W> {
+    private _finalizer;
+    private _registry;
+    acquire(regNum: string, resource: W): {
+        readonly descriptor: string;
+        readonly resource: W;
+        addChannelAt(sMapHash: string, channel: Channel): {
+            readonly descriptor: string;
+            readonly isValid: boolean;
+            readonly resource: W_1;
+            readonly size: number;
+            readonly useStore: () => Store;
+            dec: () => void;
+            inc(): void;
+        };
+        getChannelHandleAt(sMapHash: string): {
+            readonly descriptor: string;
+            readonly isValid: boolean;
+            readonly resource: W_1;
+            readonly size: number;
+            readonly useStore: () => Store;
+            dec: () => void;
+            inc(): void;
+        };
+    };
+    createHandleFor(regNum: string): {
+        readonly descriptor: string;
+        readonly resource: W;
+        addChannelAt(sMapHash: string, channel: Channel): {
+            readonly descriptor: string;
+            readonly isValid: boolean;
+            readonly resource: W_1;
+            readonly size: number;
+            readonly useStore: () => Store;
+            dec: () => void;
+            inc(): void;
+        };
+        getChannelHandleAt(sMapHash: string): {
+            readonly descriptor: string;
+            readonly isValid: boolean;
+            readonly resource: W_1;
+            readonly size: number;
+            readonly useStore: () => Store;
+            dec: () => void;
+            inc(): void;
+        };
+    };
+    getRegNumOf(resource: W): string;
+    getResourceAt(regNum: string): W;
+}
+export declare class Observable<T extends State> extends AbstractObservable<T> {
+}
+export declare class EagleEyeUniversal<T extends State> {
+    private _context;
+    private _pCache;
+    private _obs;
+    private _util;
+    constructor();
+    get resourceMap(): ObsResource<AbstractObservable<any>>;
+    get Provider(): {
+        <const ID extends string>(props?: WithChildren<ProviderProps<T, ID>>): JSX.Element;
+        <const ID extends string>(props?: WithChildren<ProviderPropsRaw<T, ID>>): JSX.Element;
+        <const ID extends string>(props?: WithChildren<ProviderPropsPrimitive<T, ID>>): JSX.Element;
+        <const ID extends string>(props?: WithChildren<RefProps<ID>>): JSX.Element;
+    };
+    get useStream(): any;
+    provide<const ID extends string>(props?: ProviderProps<T, ID>): Point<T, ID>;
+    provide<const ID extends string>(props?: ProviderPropsRaw<T, ID>): Point<T, ID>;
+    provide<const ID extends string>(props?: ProviderPropsPrimitive<T, ID>): Point<T, ID>;
+    stream<const S extends SelectorMap>(selectorMap?: S): {
+        into<P>(WrappedComponent: ComponentType<Store<T, S> & P>): FC<P>;
+    };
+    private defineProvider;
+    private _useStream;
+}
+declare class Utility<T extends State> {
+    private context;
+    constructor(context: EagleEyeUniversal<T>);
+    getIdOf(target: AbstractObservable<T>): string;
+    getObservableAt<const ID extends string>(targetId: ID): AbstractObservable<T>;
+    hashSelectorMap<S extends SelectorMap>(selectorMap?: S): string;
+    pointAt<const ID extends string>(target?: AbstractObservable<T>): Point<T, ID>;
+    tryObservableAt<const ID extends string>(targetId: ID): AbstractObservable<T>;
+}
+export declare function createUtilityFor<T extends State>(context: EagleEyeUniversal<T>): Utility<T>;
+export declare function createContext<T extends State>(): EagleEyeUniversal<T>;
+export {};

package/dist/main/universal/index.js

@@ -0,0 +1,387 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Observable = exports.EagleEyeUniversal = void 0;
+exports.createContext = createContext;
+exports.createUtilityFor = createUtilityFor;
+var _jsxRuntime = require("react/jsx-runtime");
+var _react = require("react");
+var _jsSha = require("js-sha512");
+var _safeStableStringify = _interopRequireDefault(require("safe-stable-stringify"));
+var _ = require("..");
+var _2 = require("../../");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+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 _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+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 _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 _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 _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 _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 ChsResource = /*#__PURE__*/function () {
+  function ChsResource() {
+    var _this = this;
+    _classCallCheck(this, ChsResource);
+    _defineProperty(this, "_finalizer", new FinalizationRegistry(function (s) {
+      return _this.finalize(s);
+    }));
+    _defineProperty(this, "_registry", void 0);
+  }
+  return _createClass(ChsResource, [{
+    key: "acquire",
+    value: function acquire(sMapHash, resource) {
+      var useStore = function useStore() {
+        var _useState = (0, _react.useState)(function () {
+            return (0, _.makeStore)(resource);
+          }),
+          _useState2 = _slicedToArray(_useState, 2),
+          store = _useState2[0],
+          setStore = _useState2[1];
+        (0, _react.useEffect)(function () {
+          var fn = function fn() {
+            return setStore(_objectSpread(_objectSpread({}, store), {}, {
+              data: resource.data
+            }));
+          };
+          resource.addListener('data-changed', fn);
+          return function () {
+            return resource.removeListener('data-changed', fn);
+          };
+        }, [resource]);
+        return store;
+      };
+      this._registry[sMapHash] = {
+        channel: new WeakRef(resource),
+        numConnections: 0,
+        useStore: useStore
+      };
+      this._finalizer.register(resource, sMapHash, resource);
+      return this.createHandleFor(sMapHash);
+    }
+  }, {
+    key: "createHandleFor",
+    value: function createHandleFor(sMapHash) {
+      var _this2 = this;
+      var entry = this._registry[sMapHash];
+      var handle = {
+        get descriptor() {
+          return sMapHash;
+        },
+        get isValid() {
+          return !!entry;
+        },
+        get resource() {
+          var _entry$channel$deref, _entry$channel;
+          return entry === null || entry === void 0 || (_entry$channel$deref = (_entry$channel = entry.channel).deref) === null || _entry$channel$deref === void 0 ? void 0 : _entry$channel$deref.call(_entry$channel);
+        },
+        get size() {
+          return handle.isValid ? entry.numConnections : -1;
+        },
+        get useStore() {
+          return entry.useStore;
+        },
+        dec: function dec() {
+          if (!handle.isValid) {
+            return;
+          }
+          entry.numConnections--;
+          if (handle.size) {
+            return;
+          }
+          handle.resource.endStream();
+          _this2._finalizer.unregister(handle.resource);
+          entry.channel = null;
+          _this2.finalize(sMapHash);
+        },
+        inc: function inc() {
+          handle.isValid && entry.numConnections++;
+        }
+      };
+      return handle;
+    }
+  }, {
+    key: "getResourceAt",
+    value: function getResourceAt(sMapHash) {
+      return this.createHandleFor(sMapHash).resource;
+    }
+  }, {
+    key: "finalize",
+    value: function finalize(sMapHash) {
+      delete this._registry[sMapHash];
+    }
+  }]);
+}();
+var ObsResource = /*#__PURE__*/function () {
+  function ObsResource() {
+    var _this3 = this;
+    _classCallCheck(this, ObsResource);
+    _defineProperty(this, "_finalizer", new FinalizationRegistry(function (regKey) {
+      delete _this3._registry[regKey];
+    }));
+    _defineProperty(this, "_registry", void 0);
+  }
+  return _createClass(ObsResource, [{
+    key: "acquire",
+    value: function acquire(regNum, resource) {
+      this._registry[regNum] = {
+        channels: new ChsResource(),
+        observable: new WeakRef(resource)
+      };
+      this._finalizer.register(resource, regNum, resource);
+      return this.createHandleFor(regNum);
+    }
+  }, {
+    key: "createHandleFor",
+    value: function createHandleFor(regNum) {
+      var _this$_registry$regNu;
+      var entry = (_this$_registry$regNu = this._registry[regNum]) !== null && _this$_registry$regNu !== void 0 ? _this$_registry$regNu : {};
+      return {
+        get descriptor() {
+          return regNum;
+        },
+        get resource() {
+          var _entry$observable$der, _entry$observable;
+          return entry === null || entry === void 0 || (_entry$observable$der = (_entry$observable = entry.observable).deref) === null || _entry$observable$der === void 0 ? void 0 : _entry$observable$der.call(_entry$observable);
+        },
+        addChannelAt: function addChannelAt(sMapHash, channel) {
+          return entry === null || entry === void 0 ? void 0 : entry.channels.acquire(sMapHash, channel);
+        },
+        getChannelHandleAt: function getChannelHandleAt(sMapHash) {
+          return entry === null || entry === void 0 ? void 0 : entry.channels.createHandleFor(sMapHash);
+        }
+      };
+    }
+  }, {
+    key: "getRegNumOf",
+    value: function getRegNumOf(resource) {
+      for (var regNum in this._registry) {
+        if (this.getResourceAt(regNum) === resource) {
+          return regNum;
+        }
+      }
+    }
+  }, {
+    key: "getResourceAt",
+    value: function getResourceAt(regNum) {
+      var _this$createHandleFor;
+      return (_this$createHandleFor = this.createHandleFor(regNum)) === null || _this$createHandleFor === void 0 ? void 0 : _this$createHandleFor.resource;
+    }
+  }]);
+}();
+var genRegNum = function () {
+  var count = 0;
+  var ts = 0;
+  return function () {
+    var newTs = Date.now();
+    if (newTs === ts) {
+      count++;
+    } else {
+      ts = newTs;
+      count = 0;
+    }
+    return "".concat(count, ":").concat(ts);
+  };
+}();
+var Observable = exports.Observable = /*#__PURE__*/function (_AbstractObservable) {
+  function Observable() {
+    _classCallCheck(this, Observable);
+    return _callSuper(this, Observable, arguments);
+  }
+  _inherits(Observable, _AbstractObservable);
+  return _createClass(Observable);
+}(_.AbstractObservable);
+var EagleEyeUniversal = exports.EagleEyeUniversal = /*#__PURE__*/function () {
+  function EagleEyeUniversal() {
+    _classCallCheck(this, EagleEyeUniversal);
+    _defineProperty(this, "_context", void 0);
+    _defineProperty(this, "_pCache", null);
+    _defineProperty(this, "_obs", null);
+    _defineProperty(this, "_util", null);
+    this._context = /*#__PURE__*/(0, _react.createContext)('0:0');
+    this._pCache = this.defineProvider();
+    this._obs = new ObsResource();
+    this._util = createUtilityFor(this);
+  }
+  return _createClass(EagleEyeUniversal, [{
+    key: "resourceMap",
+    get: function get() {
+      return this._obs;
+    }
+  }, {
+    key: "Provider",
+    get: function get() {
+      return this._pCache;
+    }
+  }, {
+    key: "useStream",
+    get: function get() {
+      return this._useStream.bind(this);
+    }
+  }, {
+    key: "provide",
+    value: function provide() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var observable = props.observable;
+      if (!observable) {
+        var t = props.observableConfig;
+        observable = (0, _2.createEagleEye)(t === null || t === void 0 ? void 0 : t.value, t === null || t === void 0 ? void 0 : t.prehooks, t === null || t === void 0 ? void 0 : t.storage);
+      }
+      return this._util.pointAt(observable);
+    }
+  }, {
+    key: "stream",
+    value: function stream(selectorMap) {
+      var useStream = this.useStream;
+      return {
+        into: function into(WrappedComponent) {
+          var Container = function Container(props) {
+            var store = useStream(selectorMap);
+            return (0, _jsxRuntime.jsx)(WrappedComponent, _objectSpread({}, _objectSpread(_objectSpread({}, store), props)));
+          };
+          return Container;
+        }
+      };
+    }
+  }, {
+    key: "defineProvider",
+    value: function defineProvider() {
+      var me = this;
+      function provide() {
+        var _props$ref;
+        var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        var targetId;
+        if (!('targetId' in props)) {
+          targetId = me.provide(props).targetId;
+        } else {
+          targetId = props.targetId;
+          if (!this._util.getObservableAt(targetId)) {
+            throw new Error("No valid observable instance found at target ID, ".concat(targetId));
+          }
+        }
+        (_props$ref = props.ref) !== null && _props$ref !== void 0 ? _props$ref : props.ref = {
+          current: {}
+        };
+        props.ref.current.targetId = targetId;
+        var Context = me._context;
+        return (0, _jsxRuntime.jsx)(Context, {
+          value: targetId,
+          children: props.children
+        });
+      }
+      return provide;
+    }
+  }, {
+    key: "_useStream",
+    value: function _useStream() {
+      var _this4 = this;
+      return function (selectorMap) {
+        var _useState3 = (0, _react.useState)(function () {
+            return _this4._util.hashSelectorMap(selectorMap);
+          }),
+          _useState4 = _slicedToArray(_useState3, 2),
+          sMapHash = _useState4[0],
+          updateSMapHash = _useState4[1];
+        var targetId = (0, _react.use)(_this4._context);
+        var getStoreHook = (0, _react.useCallback)(function () {
+          var ctxHandle = _this4._obs.createHandleFor(targetId);
+          var streamHandle = ctxHandle.getChannelHandleAt(sMapHash);
+          if (!streamHandle.isValid) {
+            ctxHandle.addChannelAt(sMapHash, ctxHandle.resource.stream(selectorMap));
+            streamHandle = ctxHandle.getChannelHandleAt(sMapHash);
+          }
+          streamHandle.inc();
+          return streamHandle.useStore;
+        }, [sMapHash, selectorMap, targetId]);
+        var _useState5 = (0, _react.useState)(getStoreHook),
+          _useState6 = _slicedToArray(_useState5, 2),
+          useStore = _useState6[0],
+          updateStoreHook = _useState6[1];
+        (0, _react.useEffect)(function () {
+          return updateSMapHash(_this4._util.hashSelectorMap(selectorMap));
+        }, [selectorMap]);
+        (0, _react.useEffect)(function () {
+          return updateStoreHook(getStoreHook());
+        }, [sMapHash]);
+        return useStore();
+      };
+    }
+  }]);
+}();
+var Utility = /*#__PURE__*/function () {
+  function Utility(context) {
+    _classCallCheck(this, Utility);
+    _defineProperty(this, "context", null);
+    this.context = context;
+  }
+  return _createClass(Utility, [{
+    key: "getIdOf",
+    value: function getIdOf(target) {
+      return this.context.resourceMap.getRegNumOf(target);
+    }
+  }, {
+    key: "getObservableAt",
+    value: function getObservableAt(targetId) {
+      return this.context.resourceMap.getResourceAt(targetId);
+    }
+  }, {
+    key: "hashSelectorMap",
+    value: function hashSelectorMap(selectorMap) {
+      return (0, _jsSha.sha512)((0, _safeStableStringify["default"])(selectorMap, function (k, v) {
+        typeof v === 'undefined' ? 'undefined' : v === null ? 'null' : v;
+      }));
+    }
+  }, {
+    key: "pointAt",
+    value: function pointAt(target) {
+      if (!target) {
+        target = (0, _2.createEagleEye)();
+      } else {
+        var _targetId = this.getIdOf(target);
+        if (_targetId) {
+          return {
+            target: target,
+            targetId: _targetId
+          };
+        }
+      }
+      var targetId = genRegNum();
+      this.context.resourceMap.acquire(targetId, target);
+      return {
+        target: target,
+        targetId: targetId
+      };
+    }
+  }, {
+    key: "tryObservableAt",
+    value: function tryObservableAt(targetId) {
+      var observable = this.getObservableAt(targetId);
+      if (!observable) {
+        throw new Error("No observable entry found for the key bearing the target ID( ".concat(targetId, " )."));
+      }
+      return observable;
+    }
+  }]);
+}();
+function createUtilityFor(context) {
+  return new Utility(context);
+}
+function createContext() {
+  return new EagleEyeUniversal();
+}

package/package.json

@@ -22,6 +22,7 @@
     "@testing-library/user-event": "^14.6.1",
     "@types/jest": "^29.5.12",
     "@types/jest-cli": "^24.3.0",
+    "@types/js-sha512": "^0.7.0",
     "@types/lodash.isempty": "^4.4.9",
     "@types/lodash.isplainobject": "^4.0.9",
     "@types/node": "^20.11.28",
@@ -125,8 +126,10 @@
     "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
   },
   "types": "dist/index.d.ts",
-  "version": "1.0.5",
+  "version": "1.1.0-alpha",
   "dependencies": {
-    "@webkrafters/eagleeye": "^1.0.8"
+    "@webkrafters/eagleeye": "^1.0.8",
+    "js-sha512": "^0.9.0",
+    "safe-stable-stringify": "^2.5.0"
   }
 }