@webkrafters/react-eagleeye 1.1.0-alpha.0 → 1.1.0-alpha.10

package/README.md

@@ -44,8 +44,22 @@
 
 **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.
+**Demo:**\
+[1] [Play with the app on codesandbox](https://codesandbox.io/s/github/webKrafters/react-eagleeye-app)\
+[2] [Play with the app on codesandbox (Universal Rendering)](https://codesandbox.io/s/github/webKrafters/react-eagleeye-universal-app)\
+If sandbox fails to load app, please refresh dependencies on its lower left.\
+**OR**\
+Bring in and run the demo software locally through the following steps:\
+**Step 1:** Run either\
+&nbsp;&nbsp;&nbsp;&nbsp;`git clone https://github.com/webKrafters/react-eagleeye-app.git`\
+&nbsp;&nbsp;&nbsp;&nbsp;or\
+&nbsp;&nbsp;&nbsp;&nbsp;`git clone https://github.com/webKrafters/react-eagleeye-universal-app.git` (Universal Rendering)\
+**Step 2:** CD into the cloned directory\
+**Step 3:** Run `npm i`\
+**Step 4:** Run `npm run dev`\
+**Step 5:** Copy and paste the displayed URL into the web browser.\
+**Step 6:** Use CTRL+F5 (Mac: CMD+F5) at the browser to ensure a fresh page load if needed.\
+**Step 7:** Pay with the app.
 
 **Install:**\
 npm install --save @webkrafters/react-eagleeye

package/dist/index.d.ts

@@ -11,5 +11,5 @@ export interface IProps {
 }
 export type OwnProps = IProps & Record<any, any>;
 export { createContext as createEagleEye, type AbstractObservable, type ObservableContext as EagleEyeContext } from './main';
-export { createContext as createEagleEyeUniversal } from './main/universal';
-export type { Address as AddressUniversal, BaseProviderPropsRaw as BaseProviderPropsRawUniversal, EagleEyeUniversal, IProviderProps as IProviderPropsUniversal, Observable as ObservableUniversal, ProviderProps as ProviderPropsUniversal, ProviderPropsPrimitive as ProviderPropsPrimitiveUniversal, ProviderPropsRaw as ProviderPropsRawUniversal, RefProps as RefPropsUniversal, WithChildren as WithChildrenUniversal } from './main/universal';
+export { createContext as createEagleEyeUniverse } from './main/universe';
+export type { Address as AddressUniverse, BaseProviderPropsRaw as BaseProviderPropsRawUniverse, ObservableUniverse as EagleEyeUniverse, IProviderProps as IProviderPropsUniverse, Observable as ObservableUniverse, ProviderProps as ProviderPropsUniverse, ProviderPropsPrimitive as ProviderPropsPrimitiveUniverse, ProviderPropsRaw as ProviderPropsRawUniverse, RefProps as RefPropsUniverse, WithChildren as WithChildrenUniverse } from './main/universe';

package/dist/index.js

@@ -69,12 +69,12 @@ Object.defineProperty(exports, "createEagleEye", {
     return _main.createContext;
   }
 });
-Object.defineProperty(exports, "createEagleEyeUniversal", {
+Object.defineProperty(exports, "createEagleEyeUniverse", {
   enumerable: true,
   get: function get() {
-    return _universal.createContext;
+    return _universe.createContext;
   }
 });
 var _eagleeye = require("@webkrafters/eagleeye");
 var _main = require("./main");
-var _universal = require("./main/universal");
+var _universe = require("./main/universe");

package/dist/main/index.js

@@ -123,7 +123,6 @@ var ObservableContext = exports.ObservableContext = /*#__PURE__*/function (_Abst
     get: function get() {
       var stream = this.stream;
       return function (selectorMap) {
-        var strictMode = (0, _react.useRef)(true);
         var _useState = (0, _react.useState)(function () {
             return stream(selectorMap);
           }),
@@ -139,20 +138,13 @@ var ObservableContext = exports.ObservableContext = /*#__PURE__*/function (_Abst
           channel.selectorMap = selectorMap;
         }, [selectorMap]);
         (0, _react.useEffect)(function () {
-          if (!strictMode.current) {
-            return;
-          }
           channel.addListener('data-changed', function () {
-            return setStore(_objectSpread(_objectSpread({}, store), {}, {
-              data: channel.data
-            }));
+            return setStore(makeStore(channel));
           });
-          strictMode.current = false;
           return function () {
-            channel.endStream();
-            strictMode.current = true;
+            return channel.endStream();
           };
-        }, []);
+        }, [channel]);
         return store;
       };
     }

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

@@ -0,0 +1,135 @@
+import { FC, ComponentType, JSX, RefObject } 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 OwnPropsTemplate<P> = P extends IProviderProps<infer U> ? U : never;
+type ObservableTemplate<T> = T extends AbstractObservable<infer U> ? U : never;
+export type WithChildren<P extends IProviderProps<OwnPropsTemplate<P>>> = P & {
+    children?: React.ReactNode;
+};
+interface ChannelEntry {
+    channel: WeakRef<Channel>;
+    numConnections: number;
+}
+interface Entry {
+    channels: ChsResource<Channel>;
+    observable: WeakRef<AbstractObservable<any>>;
+}
+interface Handle<W extends WeakKey> {
+    readonly resource: W;
+}
+declare class ObserverHandle<W extends AbstractObservable<ObservableTemplate<W>>> implements Handle<W> {
+    private _wObs;
+    private _regNum;
+    constructor(obs: ObsResource<W>, regNum: string);
+    private get _obs();
+    private get _entry();
+    get resource(): W;
+    addChannelAt(sMapHash: string, channel: Channel): StreamerHandle<Channel<import("@webkrafters/auto-immutable").Value, SelectorMap>>;
+    getChannelHandleAt(sMapHash: string): StreamerHandle<Channel<import("@webkrafters/auto-immutable").Value, SelectorMap>>;
+    release(force?: boolean): void;
+}
+declare class StreamerHandle<W extends Channel> implements Handle<W> {
+    private _wChs;
+    private _sMapHash;
+    constructor(chs: ChsResource<W>, sMapHash: string);
+    private get _chs();
+    private get _entry();
+    get isValid(): boolean;
+    get resource(): W;
+    get size(): number;
+    dec(): void;
+    inc(): void;
+}
+interface IResource<W extends WeakKey> {
+    acquire(desc: string, resource: W): Handle<W>;
+    createHandleFor(desc: string): Handle<W>;
+}
+declare abstract class AbstractResource<W extends WeakKey> implements IResource<W> {
+    abstract registry: Record<string, any>;
+    get size(): number;
+    abstract acquire(desc: string, resource: W): Handle<W>;
+    abstract createHandleFor(desc: string): Handle<W>;
+    finalizer: FinalizationRegistry<string>;
+    finalize(key: string): void;
+}
+declare class ChsResource<W extends Channel> extends AbstractResource<W> {
+    registry: Record<string, ChannelEntry>;
+    acquire(sMapHash: string, resource: W): StreamerHandle<W>;
+    createHandleFor(sMapHash: string): StreamerHandle<W>;
+}
+declare class ObsResource<W extends AbstractObservable<ObservableTemplate<W>>> extends AbstractResource<W> {
+    registry: Record<string, Entry>;
+    acquire(regNum: string, resource: W): ObserverHandle<W>;
+    createHandleFor(regNum: string): ObserverHandle<W>;
+    getRegNumOf(resource: W): string;
+    removeResourceAt(regNum: string, force?: boolean): void;
+    getResourceAt(regNum: string): W;
+}
+export declare class Observable<T extends State> extends AbstractObservable<T> {
+}
+export declare class ObservableUniverse<T extends State> {
+    private _context;
+    private _pCache;
+    private _obs;
+    private _sCache;
+    private _util;
+    constructor();
+    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(): <const S extends SelectorMap>(selectorMap?: S) => Store<T, S>;
+    free(observable: AbstractObservable<T>, force?: boolean): void;
+    free(observable: string, force?: boolean): void;
+    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>;
+    secureResourceMapFor(requestor: Utility<T>): ObsResource<AbstractObservable<any>>;
+    stream<const S extends SelectorMap>(selectorMap?: S): {
+        into<P>(WrappedComponent: ComponentType<Store<T, S> & P>): FC<P>;
+    };
+    getIdOf(observable: AbstractObservable<T>): string;
+    getObservableAt<const ID extends string>(id: ID): AbstractObservable<T>;
+    private defineProvider;
+    private defineStreamHook;
+}
+export declare class Utility<T extends State> {
+    private _wContext;
+    constructor(context: ObservableUniverse<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>;
+    untrack(target: AbstractObservable<T>, force?: boolean): void;
+    untrackId<const ID extends string>(targetId: ID, force?: boolean): void;
+    private get _context();
+    private get _registry();
+}
+export declare function createContext<T extends State>(): ObservableUniverse<T>;
+export {};

package/dist/main/{universal → universe}/index.js

@@ -3,16 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Observable = exports.EagleEyeUniversal = void 0;
+exports.Utility = exports.ObservableUniverse = exports.Observable = void 0;
 exports.createContext = createContext;
 var _jsxRuntime = require("react/jsx-runtime");
 var _react = require("react");
-var _jsSha = require("js-sha512");
+var _lodash = _interopRequireDefault(require("lodash.isplainobject"));
 var _safeStableStringify = _interopRequireDefault(require("safe-stable-stringify"));
+var _jsSha = require("js-sha512");
 var _ = require("..");
-var _2 = 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 _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 _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; }
@@ -20,170 +29,218 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
 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 ObserverHandle = /*#__PURE__*/function () {
+  function ObserverHandle(obs, regNum) {
+    _classCallCheck(this, ObserverHandle);
+    _defineProperty(this, "_wObs", void 0);
+    _defineProperty(this, "_regNum", void 0);
+    this._wObs = new WeakRef(obs);
+    this._regNum = regNum;
+  }
+  return _createClass(ObserverHandle, [{
+    key: "_obs",
+    get: function get() {
+      return this._wObs.deref();
+    }
+  }, {
+    key: "_entry",
+    get: function get() {
+      var _this$_obs$registry$t;
+      return (_this$_obs$registry$t = this._obs.registry[this._regNum]) !== null && _this$_obs$registry$t !== void 0 ? _this$_obs$registry$t : {};
+    }
+  }, {
+    key: "resource",
+    get: function get() {
+      var _this$_entry, _this$_entry$deref;
+      return (_this$_entry = this._entry) === null || _this$_entry === void 0 || (_this$_entry = _this$_entry.observable) === null || _this$_entry === void 0 || (_this$_entry$deref = _this$_entry.deref) === null || _this$_entry$deref === void 0 ? void 0 : _this$_entry$deref.call(_this$_entry);
+    }
+  }, {
+    key: "addChannelAt",
+    value: function addChannelAt(sMapHash, channel) {
+      var _this$_entry2;
+      return (_this$_entry2 = this._entry) === null || _this$_entry2 === void 0 ? void 0 : _this$_entry2.channels.acquire(sMapHash, channel);
+    }
+  }, {
+    key: "getChannelHandleAt",
+    value: function getChannelHandleAt(sMapHash) {
+      var _this$_entry3;
+      return (_this$_entry3 = this._entry) === null || _this$_entry3 === void 0 ? void 0 : _this$_entry3.channels.createHandleFor(sMapHash);
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      if (!force && this._entry.channels.size) {
+        return;
+      }
+      this._obs.finalizer.unregister(this.resource);
+      this._entry.observable = null;
+      this._obs.finalize(this._regNum);
+    }
+  }]);
+}();
+var StreamerHandle = /*#__PURE__*/function () {
+  function StreamerHandle(chs, sMapHash) {
+    _classCallCheck(this, StreamerHandle);
+    _defineProperty(this, "_wChs", void 0);
+    _defineProperty(this, "_sMapHash", void 0);
+    this._wChs = new WeakRef(chs);
+    this._sMapHash = sMapHash;
+  }
+  return _createClass(StreamerHandle, [{
+    key: "_chs",
+    get: function get() {
+      return this._wChs.deref();
+    }
+  }, {
+    key: "_entry",
+    get: function get() {
+      var _this$_chs;
+      return (_this$_chs = this._chs) === null || _this$_chs === void 0 ? void 0 : _this$_chs.registry[this._sMapHash];
+    }
+  }, {
+    key: "isValid",
+    get: function get() {
+      return !!this._entry;
+    }
+  }, {
+    key: "resource",
+    get: function get() {
+      var _this$_entry4, _this$_entry4$deref;
+      return (_this$_entry4 = this._entry) === null || _this$_entry4 === void 0 || (_this$_entry4 = _this$_entry4.channel) === null || _this$_entry4 === void 0 || (_this$_entry4$deref = _this$_entry4.deref) === null || _this$_entry4$deref === void 0 ? void 0 : _this$_entry4$deref.call(_this$_entry4);
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.isValid ? this._entry.numConnections : -1;
+    }
+  }, {
+    key: "dec",
+    value: function dec() {
+      if (!this.isValid) {
+        return;
+      }
+      this._entry.numConnections--;
+      if (this.size) {
+        return;
+      }
+      this.resource.endStream();
+      this._chs.finalizer.unregister(this.resource);
+      this._entry.channel = null;
+      this._chs.finalize(this._sMapHash);
+    }
+  }, {
+    key: "inc",
+    value: function inc() {
+      this.isValid && this._entry.numConnections++;
+    }
+  }]);
+}();
+var AbstractResource = /*#__PURE__*/function () {
+  function AbstractResource() {
     var _this = this;
-    _classCallCheck(this, ChsResource);
-    _defineProperty(this, "_finalizer", new FinalizationRegistry(function (s) {
+    _classCallCheck(this, AbstractResource);
+    _defineProperty(this, "finalizer", new FinalizationRegistry(function (s) {
       return _this.finalize(s);
     }));
-    _defineProperty(this, "_registry", void 0);
   }
+  return _createClass(AbstractResource, [{
+    key: "size",
+    get: function get() {
+      return Object.keys(this.registry).length;
+    }
+  }, {
+    key: "finalize",
+    value: function finalize(key) {
+      delete this.registry[key];
+    }
+  }]);
+}();
+var ChsResource = /*#__PURE__*/function (_AbstractResource2) {
+  function ChsResource() {
+    var _this2;
+    _classCallCheck(this, ChsResource);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this2 = _callSuper(this, ChsResource, [].concat(args));
+    _defineProperty(_this2, "registry", {});
+    return _this2;
+  }
+  _inherits(ChsResource, _AbstractResource2);
   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] = {
+      this.registry[sMapHash] = {
         channel: new WeakRef(resource),
-        numConnections: 0,
-        useStore: useStore
+        numConnections: 0
       };
-      this._finalizer.register(resource, sMapHash, resource);
+      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];
+      return new StreamerHandle(this, sMapHash);
     }
   }]);
-}();
-var ObsResource = /*#__PURE__*/function () {
+}(AbstractResource);
+var ObsResource = /*#__PURE__*/function (_AbstractResource3) {
   function ObsResource() {
-    var _this3 = this;
+    var _this3;
     _classCallCheck(this, ObsResource);
-    _defineProperty(this, "_finalizer", new FinalizationRegistry(function (regKey) {
-      delete _this3._registry[regKey];
-    }));
-    _defineProperty(this, "_registry", void 0);
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    _this3 = _callSuper(this, ObsResource, [].concat(args));
+    _defineProperty(_this3, "registry", {});
+    return _this3;
   }
+  _inherits(ObsResource, _AbstractResource3);
   return _createClass(ObsResource, [{
     key: "acquire",
     value: function acquire(regNum, resource) {
-      this._registry[regNum] = {
+      this.registry[regNum] = {
         channels: new ChsResource(),
         observable: new WeakRef(resource)
       };
-      this._finalizer.register(resource, regNum, 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);
-        }
-      };
+      return new ObserverHandle(this, regNum);
     }
   }, {
     key: "getRegNumOf",
     value: function getRegNumOf(resource) {
-      for (var regNum in this._registry) {
+      for (var regNum in this.registry) {
         if (this.getResourceAt(regNum) === resource) {
           return regNum;
         }
       }
     }
+  }, {
+    key: "removeResourceAt",
+    value: function removeResourceAt(regNum, force) {
+      var _this$createHandleFor;
+      (_this$createHandleFor = this.createHandleFor(regNum)) === null || _this$createHandleFor === void 0 || _this$createHandleFor.release(force);
+    }
   }, {
     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 _this$createHandleFor2;
+      return (_this$createHandleFor2 = this.createHandleFor(regNum)) === null || _this$createHandleFor2 === void 0 ? void 0 : _this$createHandleFor2.resource;
     }
   }]);
-}();
+}(AbstractResource);
 var genRegNum = function () {
   var count = 0;
   var ts = 0;
@@ -206,24 +263,21 @@ var Observable = exports.Observable = /*#__PURE__*/function (_AbstractObservable
   _inherits(Observable, _AbstractObservable);
   return _createClass(Observable);
 }(_.AbstractObservable);
-var EagleEyeUniversal = exports.EagleEyeUniversal = /*#__PURE__*/function () {
-  function EagleEyeUniversal() {
-    _classCallCheck(this, EagleEyeUniversal);
+var ObservableUniverse = exports.ObservableUniverse = /*#__PURE__*/function () {
+  function ObservableUniverse() {
+    _classCallCheck(this, ObservableUniverse);
     _defineProperty(this, "_context", void 0);
     _defineProperty(this, "_pCache", null);
     _defineProperty(this, "_obs", null);
+    _defineProperty(this, "_sCache", null);
     _defineProperty(this, "_util", null);
     this._context = /*#__PURE__*/(0, _react.createContext)('0:0');
     this._pCache = this.defineProvider();
     this._obs = new ObsResource();
+    this._sCache = this.defineStreamHook();
     this._util = new Utility(this);
   }
-  return _createClass(EagleEyeUniversal, [{
-    key: "resourceMap",
-    get: function get() {
-      return this._obs;
-    }
-  }, {
+  return _createClass(ObservableUniverse, [{
     key: "Provider",
     get: function get() {
       return this._pCache;
@@ -231,7 +285,12 @@ var EagleEyeUniversal = exports.EagleEyeUniversal = /*#__PURE__*/function () {
   }, {
     key: "useStream",
     get: function get() {
-      return this._useStream.bind(this);
+      return this._sCache;
+    }
+  }, {
+    key: "free",
+    value: function free(observable, force) {
+      !(observable instanceof _.AbstractObservable) ? this._util.untrackId(observable, force) : this._util.untrack(observable, force);
     }
   }, {
     key: "provide",
@@ -244,6 +303,14 @@ var EagleEyeUniversal = exports.EagleEyeUniversal = /*#__PURE__*/function () {
       }
       return this._util.pointAt(observable);
     }
+  }, {
+    key: "secureResourceMapFor",
+    value: function secureResourceMapFor(requestor) {
+      if (requestor === this._util) {
+        return this._obs;
+      }
+      throw new Error('Illegal operation.');
+    }
   }, {
     key: "stream",
     value: function stream(selectorMap) {
@@ -273,42 +340,74 @@ var EagleEyeUniversal = exports.EagleEyeUniversal = /*#__PURE__*/function () {
     value: function defineProvider() {
       var me = this;
       function provide() {
-        var _props$ref;
+        var _props$observableConf, _props$observableConf2, _props$observableConf3, _props$ref$current;
         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));
+        var id = (0, _react.useRef)(null);
+        (0, _react.useMemo)(function () {
+          if ('targetId' in props) {
+            if (!me.getObservableAt(props.targetId)) {
+              throw new Error("No valid observable instance found at target ID, ".concat(props.targetId));
+            }
+            id.current = props.targetId;
+            return;
+          }
+          if (!id.current || 'observable' in props) {
+            id.current = me.provide(props).targetId;
+            return;
+          }
+          var ctx = me.getObservableAt(id.current);
+          if (!('observableConfig' in props)) {
+            return;
+          }
+          var config = props.observableConfig;
+          if ('storage' in config && config.storage !== ctx.storage) {
+            ctx.storage = config.storage;
+          }
+          if ('prehooks' in config && config.prehooks !== ctx.prehooks) {
+            ctx.prehooks = config.prehooks;
+          }
+          if (!('value' in config)) {
+            return;
           }
+          if ((0, _lodash["default"])(config.value)) {
+            return ctx.store.setState(config.value);
+          }
+          var connection = config.value.connect();
+          var value = connection.get('@@GLOBAL')['@@GLOBAL'];
+          connection.disconnect();
+          ctx.store.setState(value);
+        }, [(_props$observableConf = props.observableConfig) === null || _props$observableConf === void 0 ? void 0 : _props$observableConf.value, props.targetId, props.observable, (_props$observableConf2 = props.observableConfig) === null || _props$observableConf2 === void 0 ? void 0 : _props$observableConf2.prehooks, (_props$observableConf3 = props.observableConfig) === null || _props$observableConf3 === void 0 ? void 0 : _props$observableConf3.storage]);
+        if ('ref' in props && ((_props$ref$current = props.ref.current) === null || _props$ref$current === void 0 ? void 0 : _props$ref$current.targetId) !== id.current) {
+          if (!props.ref.current) {
+            props.ref.current = {};
+          }
+          ;
+          props.ref.current.targetId = id.current;
         }
-        (_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,
+          value: id.current,
           children: props.children
         });
       }
       return provide;
     }
   }, {
-    key: "_useStream",
-    value: function _useStream() {
+    key: "defineStreamHook",
+    value: function defineStreamHook() {
       var _this4 = this;
       return function (selectorMap) {
-        var _useState3 = (0, _react.useState)(function () {
+        var _useState = (0, _react.useState)(function () {
             return _this4._util.hashSelectorMap(selectorMap);
           }),
-          _useState4 = _slicedToArray(_useState3, 2),
-          sMapHash = _useState4[0],
-          updateSMapHash = _useState4[1];
+          _useState2 = _slicedToArray(_useState, 2),
+          sMapHash = _useState2[0],
+          updateSMapHash = _useState2[1];
+        (0, _react.useEffect)(function () {
+          return updateSMapHash(_this4._util.hashSelectorMap(selectorMap));
+        }, [selectorMap]);
         var targetId = (0, _react.use)(_this4._context);
-        var getStoreHook = (0, _react.useCallback)(function () {
+        var handle = (0, _react.useMemo)(function () {
           var ctxHandle = _this4._obs.createHandleFor(targetId);
           var streamHandle = ctxHandle.getChannelHandleAt(sMapHash);
           if (!streamHandle.isValid) {
@@ -316,69 +415,90 @@ var EagleEyeUniversal = exports.EagleEyeUniversal = /*#__PURE__*/function () {
             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]);
+          return streamHandle;
+        }, [sMapHash, targetId]);
+        var _useState3 = (0, _react.useState)(function () {
+            return (0, _.makeStore)(handle.resource);
+          }),
+          _useState4 = _slicedToArray(_useState3, 2),
+          store = _useState4[0],
+          setStore = _useState4[1];
         (0, _react.useEffect)(function () {
-          return updateStoreHook(getStoreHook());
-        }, [sMapHash]);
-        return useStore();
+          var fn = function fn() {
+            return setStore((0, _.makeStore)(handle.resource));
+          };
+          handle.resource.addListener('data-changed', fn);
+          return function () {
+            handle.resource.removeListener('data-changed', fn);
+            handle.dec();
+          };
+        }, [handle.resource]);
+        return store;
       };
     }
   }]);
 }();
-var Utility = /*#__PURE__*/function () {
+var Utility = exports.Utility = /*#__PURE__*/function () {
   function Utility(context) {
     _classCallCheck(this, Utility);
-    _defineProperty(this, "context", null);
-    this.context = context;
+    _defineProperty(this, "_wContext", void 0);
+    this._wContext = new WeakRef(context);
   }
   return _createClass(Utility, [{
     key: "getIdOf",
     value: function getIdOf(target) {
-      return this.context.resourceMap.getRegNumOf(target);
+      return this._registry.getRegNumOf(target);
     }
   }, {
     key: "getObservableAt",
     value: function getObservableAt(targetId) {
-      return this.context.resourceMap.getResourceAt(targetId);
+      return this._registry.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;
-      }));
+      return (0, _jsSha.sha512)(typeof selectorMap === 'undefined' ? 'undefined' : selectorMap === null ? 'null' : (0, _safeStableStringify["default"])(selectorMap));
     }
   }, {
     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 = this.getIdOf(target);
+      if (targetId) {
+        return {
+          target: target,
+          targetId: targetId
+        };
       }
-      var targetId = genRegNum();
-      this.context.resourceMap.acquire(targetId, target);
+      targetId = genRegNum();
+      this._registry.acquire(targetId, target);
       return {
         target: target,
         targetId: targetId
       };
     }
+  }, {
+    key: "untrack",
+    value: function untrack(target, force) {
+      this.untrackId(this.getIdOf(target), force);
+    }
+  }, {
+    key: "untrackId",
+    value: function untrackId(targetId, force) {
+      var _this$_registry;
+      (_this$_registry = this._registry) === null || _this$_registry === void 0 || _this$_registry.removeResourceAt(targetId, force);
+    }
+  }, {
+    key: "_context",
+    get: function get() {
+      return this._wContext.deref();
+    }
+  }, {
+    key: "_registry",
+    get: function get() {
+      return this._context.secureResourceMapFor(this);
+    }
   }]);
 }();
 function createContext() {
-  return new EagleEyeUniversal();
+  return new ObservableUniverse();
 }

package/package.json

@@ -28,6 +28,7 @@
     "@types/node": "^20.11.28",
     "@types/react": "^19.2.9",
     "@types/react-dom": "^19.2.3",
+    "@webkrafters/auto-immutable": "^2.0.5",
     "@webkrafters/clone-total": "^1.0.1",
     "@webkrafters/get-property": "^2.0.0",
     "@webkrafters/path-dotize": "0.0.2",
@@ -56,7 +57,6 @@
     "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",
@@ -126,7 +126,7 @@
     "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
   },
   "types": "dist/index.d.ts",
-  "version": "1.1.0-alpha.0",
+  "version": "1.1.0-alpha.10",
   "dependencies": {
     "@webkrafters/eagleeye": "^1.0.8",
     "js-sha512": "^0.9.0",

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

@@ -1,153 +0,0 @@
-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>;
-    };
-    getIdOf(observable: AbstractObservable<T>): string;
-    getObservableAt<const ID extends string>(id: ID): AbstractObservable<T>;
-    private defineProvider;
-    private _useStream;
-}
-export declare function createContext<T extends State>(): EagleEyeUniversal<T>;
-export {};