@webkrafters/react-observable-context 3.0.0 → 4.0.0-alpha.1

package/dist/model/atom/index.d.ts

@@ -0,0 +1 @@
+export default Atom;
    [x: string]: any;
    get value(): Readonly<Value>;
    /**
     * @param {number} accessorId
     * @returns {number} Number of connections remaining
     */
    connect(accessorId: number): number;
    /**
     * @param {number} accessorId
     * @returns {number} Number of connections remaining
     */
    disconnect(accessorId: number): number;
    /** @param {number} accessorId */
    isConnected(accessorId: number): boolean;
    /** @param {Value|Readonly<Value>} newValue */
    setValue(newValue: Value | Readonly<Value>): void;
    #private;

package/dist/model/atom/index.js

@@ -0,0 +1,76 @@
+"use strict";
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+var _connections = new WeakMap();
+var _value = new WeakMap();
+/** An atom represents an entry for each individual property path of the state still in use by client components */
+var Atom = function () {
+  /** @type {Set<number>} */
+  /** @type {Readonly<Value>} */
+  function Atom() {
+    _classCallCheck(this, Atom);
+    _classPrivateFieldInitSpec(this, _connections, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _value, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _connections, new Set());
+    _classPrivateFieldSet(this, _value, (0, _utils.makeReadonly)({}));
+  }
+  _createClass(Atom, [{
+    key: "value",
+    get: function get() {
+      return _classPrivateFieldGet(this, _value);
+    }
+    /**
     * @param {number} accessorId
     * @returns {number} Number of connections remaining
     */
+  }, {
+    key: "connect",
+    value: function connect(accessorId) {
+      _classPrivateFieldGet(this, _connections).add(accessorId);
+      return _classPrivateFieldGet(this, _connections).size;
+    }
+    /**
     * @param {number} accessorId
     * @returns {number} Number of connections remaining
     */
+  }, {
+    key: "disconnect",
+    value: function disconnect(accessorId) {
+      _classPrivateFieldGet(this, _connections)["delete"](accessorId);
+      return _classPrivateFieldGet(this, _connections).size;
+    }
+    /** @param {number} accessorId */
+  }, {
+    key: "isConnected",
+    value: function isConnected(accessorId) {
+      return _classPrivateFieldGet(this, _connections).has(accessorId);
+    }
+    /** @param {Value|Readonly<Value>} newValue */
+  }, {
+    key: "setValue",
+    value: function setValue(newValue) {
+      _classPrivateFieldSet(this, _value, (0, _utils.makeReadonly)((0, _lodash["default"])(newValue)));
+    }
+  }]);
+  return Atom;
+}();
+var _default = Atom;
+exports["default"] = _default;

package/dist/model/storage/index.d.ts

@@ -0,0 +1 @@
+export default Storage;
 * @extends {IStorage<T>}
 * @template {State} T
 */
    static supportsSession: boolean;
    get isKeyRequired(): boolean;
    getItem(key: string): T;
    removeItem(key: string): void;
    setItem(key: string, data: T): void;
    #private;

package/dist/model/storage/index.js

@@ -0,0 +1,129 @@
+"use strict";
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+var _globalThis$sessionSt;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+var _data = new WeakMap();
+/**
 * @class
 * @template {State} T
 */
+var MemoryStorage = function () {
+  /** @type {T} */
+  function MemoryStorage() {
+    _classCallCheck(this, MemoryStorage);
+    _classPrivateFieldInitSpec(this, _data, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _data, null);
+  }
+  /** @type {IStorage<T>[ "getItem" ]} */
+  _createClass(MemoryStorage, [{
+    key: "getItem",
+    value: function getItem(key) {
+      return (0, _lodash["default"])(_classPrivateFieldGet(this, _data));
+    }
+    /** @type {IStorage<T>[ "removeItem" ]} */
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      _classPrivateFieldSet(this, _data, null);
+    }
+    /** @type {IStorage<T>[ "setItem" ]} */
+  }, {
+    key: "setItem",
+    value: function setItem(key, data) {
+      _classPrivateFieldSet(this, _data, (0, _lodash["default"])(data));
+    }
+  }]);
+  return MemoryStorage;
+}();
+/**
 * @extends {IStorage<T>}
 * @template {State} T
 */
+var _storage = new WeakMap();
+var SessionStorage = function () {
+  /** @type {IStorage<T>} */
+  function SessionStorage() {
+    _classCallCheck(this, SessionStorage);
+    _classPrivateFieldInitSpec(this, _storage, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _storage, globalThis.sessionStorage);
+  }
+  /** @type {IStorage<T>[ "getItem" ]} */
+  _createClass(SessionStorage, [{
+    key: "getItem",
+    value: function getItem(key) {
+      return JSON.parse(_classPrivateFieldGet(this, _storage).getItem(key));
+    }
+    /** @type {IStorage<T>[ "removeItem" ]} */
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      return _classPrivateFieldGet(this, _storage).removeItem(key);
+    }
+    /** @type {IStorage<T>[ "setItem" ]} */
+  }, {
+    key: "setItem",
+    value: function setItem(key, data) {
+      return _classPrivateFieldGet(this, _storage).setItem(key, JSON.stringify(data));
+    }
+  }]);
+  return SessionStorage;
+}();
+/**
 * @extends {IStorage<T>}
 * @template {State} T
 */
+var _storage2 = new WeakMap();
+var Storage = function () {
+  /** @type {IStorage<T>} */
+  function Storage() {
+    _classCallCheck(this, Storage);
+    _classPrivateFieldInitSpec(this, _storage2, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _storage2, Storage.supportsSession ? new SessionStorage() : new MemoryStorage());
+  }
+  _createClass(Storage, [{
+    key: "isKeyRequired",
+    get: function get() {
+      return _classPrivateFieldGet(this, _storage2) instanceof SessionStorage;
+    }
+    /** @type {IStorage<T>[ "getItem" ]} */
+  }, {
+    key: "getItem",
+    value: function getItem(key) {
+      return _classPrivateFieldGet(this, _storage2).getItem(key);
+    }
+    /** @type {IStorage<T>[ "removeItem" ]} */
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      _classPrivateFieldGet(this, _storage2).removeItem(key);
+    }
+    /** @type {IStorage<T>[ "setItem" ]} */
+  }, {
+    key: "setItem",
+    value: function setItem(key, data) {
+      _classPrivateFieldGet(this, _storage2).setItem(key, data);
+    }
+  }]);
+  return Storage;
+}();
+_defineProperty(Storage, "supportsSession", typeof ((_globalThis$sessionSt = globalThis.sessionStorage) === null || _globalThis$sessionSt === void 0 ? void 0 : _globalThis$sessionSt.setItem) === 'undefined');
+var _default = Storage;
+exports["default"] = _default;

package/dist/types.d.ts

@@ -0,0 +1 @@
+declare const _default: any;
    getItem: (key: string) => T;
    removeItem: (key: string) => void;
    setItem: (key: string, data: T) => void;
    getState: NonReactUsageReport;
    resetState: NonReactUsageReport;
    setState: NonReactUsageReport;
    subscribe: NonReactUsageReport;
    resetState?: (state: {
        current: T;
        original: T;
    }) => boolean;
    setState?: (newChanges: PartialState<T>) => boolean;
    [x: string]: any;
    resetState: VoidFunction;
    setState: (changes: PartialState<T>) => void;
    getState: (clientId: string, ...propertyPaths?: string[]) => Readonly<PartialState<T>>;
    subscribe: (listener: Listener<T>) => Unsubscribe;
    unlinkCache: (clientId: string) => void;
    data: PartialState<T>;
    resetState: VoidFunction;
    setState: (changes: PartialState<T>) => void;

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export function makeReadonly<T>(v: T): Readonly<T>;

package/dist/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeReadonly = void 0;
+var _lodash = _interopRequireDefault(require("lodash.isplainobject"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
 * Converts argument to readonly.
 *
 * Note: Mutates original argument.
 *
 * @param {T} v
 * @returns {Readonly<T>}
 * @template T
 */
+var makeReadonly = function makeReadonly(v) {
+  var frozen = true;
+  if ((0, _lodash["default"])(v)) {
+    for (var k in v) {
+      makeReadonly(v[k]);
+    }
+    frozen = Object.isFrozen(v);
+  } else if (Array.isArray(v)) {
+    var vLen = v.length;
+    for (var i = 0; i < vLen; i++) {
+      makeReadonly(v[i]);
+    }
+    frozen = Object.isFrozen(v);
+  }
+  !frozen && Object.freeze(v);
+  return v;
+};
+exports.makeReadonly = makeReadonly;

package/index.js

@@ -1 +1 @@
-module.exports = require( './dist' );
+module.exports = require( './dist/main' );

package/package.json

@@ -8,31 +8,35 @@
   ],
   "dependencies": {
     "lodash.clonedeep": "^4.5.0",
-    "lodash.has": "^4.5.2",
+    "lodash.get": "^4.4.2",
     "lodash.isempty": "^4.4.0",
     "lodash.isequal": "^4.5.0",
     "lodash.isplainobject": "^4.0.6",
-    "lodash.omit": "^4.5.0"
+    "lodash.omit": "^4.5.0",
+    "lodash.pick": "^4.4.0",
+    "lodash.set": "^4.3.2",
+    "uuid": "^9.0.0"
   },
   "description": "Observable react context - prevents an automatic total component tree tear-down and re-rendering during context updates.",
   "devDependencies": {
     "@babel/cli": "^7.17.0",
-    "@babel/core": "^7.12.10",
+    "@babel/core": "^7.20.5",
     "@babel/node": "^7.12.10",
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
     "@babel/plugin-transform-runtime": "^7.17.0",
-    "@babel/preset-env": "^7.12.11",
+    "@babel/preset-env": "^7.20.2",
     "@babel/preset-react": "^7.18.6",
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^13.4.0",
+    "@testing-library/react-hooks": "^8.0.1",
     "@testing-library/user-event": "^14.4.3",
     "@types/jest-cli": "^24.3.0",
     "babel-jest": "^26.6.3",
     "babel-loader": "^8.2.5",
-    "eslint": "^7.15.0",
+    "eslint": "^8.29.0",
     "eslint-config-standard": "^16.0.2",
     "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jest": "^24.1.3",
+    "eslint-plugin-jest": "^26.0.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^4.2.1",
     "eslint-plugin-react": "^7.31.11",
@@ -44,9 +48,32 @@
     "typescript": "^4.8.2"
   },
   "files": [
-    "dist/index.js",
-    "dist/index.d.ts",
-    "index",
+    "dist/constants.js",
+    "dist/constants.d.ts",
+    "dist/main/index.js",
+    "dist/main/index.d.ts",
+    "dist/main/set-state/index.js",
+    "dist/main/set-state/index.d.ts",
+    "dist/main/hooks/use-prehooks-ref/index.js",
+    "dist/main/hooks/use-prehooks-ref/index.d.ts",
+    "dist/main/hooks/use-render-keys-manager/index.js",
+    "dist/main/hooks/use-render-keys-manager/index.d.ts",
+    "dist/main/hooks/use-state-manager/index.js",
+    "dist/main/hooks/use-state-manager/index.d.ts",
+    "dist/main/hooks/use-store/index.js",
+    "dist/main/hooks/use-store/index.d.ts",
+    "dist/model/accessor/index.js",
+    "dist/model/accessor/index.d.ts",
+    "dist/model/accessor-cache/index.js",
+    "dist/model/accessor-cache/index.d.ts",
+    "dist/model/atom/index.js",
+    "dist/model/atom/index.d.ts",
+    "dist/model/storage/index.js",
+    "dist/model/storage/index.d.ts",
+    "dist/utils/index.js",
+    "dist/utils/index.d.ts",
+    "dist/types.d.ts",
+    "index.js",
     "package.json"
   ],
   "homepage": "https://github.com/steveswork/react-observable-context#readme",
@@ -76,10 +103,10 @@
     "url": "git+https://github.com/steveswork/react-observable-context.git"
   },
   "scripts": {
-    "build": "eslint --fix && rm -rf dist && babel src -d dist && npx -p typescript tsc",
+    "build": "eslint --fix && rm -rf dist && babel src -d dist && npx -p typescript tsc && node ./trim-comments",
     "test": "eslint --fix && jest --updateSnapshot",
     "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
   },
-  "types": "dist/index.d.ts",
-  "version": "3.0.0"
+  "types": "dist/main/index.d.ts",
+  "version": "4.0.0-alpha.1"
 }

package/dist/index.d.ts

@@ -1,33 +0,0 @@
-export class UsageError extends Error {
-}
-export function createContext<T_1 extends State>(): import("react").Context<Store<T_1>>;
-export function useContext<T_1 extends State>(context: import("react").Context<Store<T_1>>, watchedKeys?: (string | keyof T_1)[]): Store<T_1>;
-export type ObservableContext<T_1 extends State> = Context<Store<T>>;
-export type OptionalTask<F = void> = F extends void ? () => never : F;
-export type Listener<T_1 extends State> = (newValue: PartialState<T>, oldValue: PartialState<T>) => void;
-export type State = {
-    [x: string]: any;
-};
-export type PartialState<T_1 extends State> = {
-    [x: string]: any;
-} & { [K in keyof T]?: T[K]; };
-export type Selector<T_1 extends State> = (state: T) => any;
-export type Prehooks<T_1 extends State> = {
-    resetState?: (state: {
-        current: T;
-        original: T;
-    }) => boolean;
-    setState?: (newChanges: PartialState<T>) => boolean;
-};
-export type Store<T_1 extends State> = {
-    getState: (selector?: Selector<T>) => any;
-    resetState: OptionalTask<VoidFunction>;
-    setState: (changes: PartialState<T>) => void;
-    subscribe: (listener: Listener<T>) => Unsubscribe;
-};
-export type Unsubscribe = VoidFunction;
-export type ReactNode = import("react").ReactNode;
-export type FC<P = {}> = import("react").FC<P>;
-export type Provider<T_1> = import("react").Provider<T>;
-export type Context<T_1> = import("react").Context<T>;
-//# sourceMappingURL=index.d.ts.map